Fail on ambiguous names and type Bun SQL rows

Author: tylergannon

.github/workflows/ci.yml

@@ -33,6 +33,9 @@ jobs:
 
     - name: Install dependencies
       run: bun install
+
+    - name: Run unit tests
+      run: bun test
 
     - name: Build WASM plugin
       run: just plugin-wasm

.github/workflows/release.yml

@@ -34,6 +34,9 @@ jobs:
       - name: Install dependencies
         run: bun install
 
+      - name: Run unit tests
+        run: bun test
+
       - name: Build WASM plugin
         run: just plugin-wasm && mv examples/plugin.wasm sqlc-gen-typescript.wasm
 

.oxfmtrc.json

@@ -0,0 +1,8 @@
+{
+	"$schema": "./node_modules/oxfmt/configuration_schema.json",
+	"useTabs": false,
+	"singleQuote": false,
+	"trailingComma": "all",
+	"printWidth": 100,
+	"ignorePatterns": ["out.js", "src/gen/plugin/codegen_pb.ts", "examples/**", "node_modules/**"]
+}

.oxlintrc.json

@@ -0,0 +1,17 @@
+{
+	"plugins": ["typescript", "import", "unicorn"],
+	"categories": {
+		"correctness": "error"
+	},
+	"rules": {
+		"import/order": [
+			"error",
+			{
+				"groups": ["builtin", "external", "internal", "parent", "sibling", "index"],
+				"newlines-between": "always",
+				"alphabetize": { "order": "asc", "caseInsensitive": true }
+			}
+		]
+	},
+	"ignorePatterns": ["out.js", "src/gen/plugin/codegen_pb.ts", "examples/**", "node_modules/**"]
+}

Justfile

@@ -20,5 +20,17 @@ codegen-proto:
 clean:
     rm -f out.js examples/plugin.wasm
 
+# Format TypeScript
+fmt:
+    bunx oxfmt
+
+# Lint TypeScript
+lint:
+    bunx oxlint --deny-warnings
+
+# Run unit tests
+test:
+    bun test
+
 # Build everything from scratch
 build: clean generate

bun.lock

@@ -4,12 +4,15 @@
   "description": "",
   "main": "app.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "bun test"
   },
   "author": "",
   "license": "ISC",
   "devDependencies": {
+    "@types/bun": "^1.3.5",
     "esbuild": "^0.19.5",
+    "oxfmt": "^0.19.0",
+    "oxlint": "^1.34.0",
     "typescript": "^5.2.2"
   },
   "dependencies": {

package.json

@@ -27,6 +27,8 @@ import {
 } from "./gen/plugin/codegen_pb";
 
 import { argName, colName } from "./drivers/utlis";
+import { rowValuesDecl } from "./decls";
+import { assertUniqueNames } from "./validate";
 import { Driver as Sqlite3Driver } from "./drivers/better-sqlite3";
 import { Driver as PgDriver } from "./drivers/pg";
 import { Driver as PostgresDriver } from "./drivers/postgres";
@@ -127,23 +129,11 @@ function codegen(input: GenerateRequest): GenerateResponse {
     qs?.push(query);
   }
 
-  for (const [filename, queries] of querymap.entries()) {
-    const nodes = driver.preamble(queries);
+    for (const [filename, queries] of querymap.entries()) {
+      const nodes = driver.preamble(queries);
 
-    for (const query of queries) {
-      const colmap = new Map<string, number>();
-      for (let column of query.columns) {
-        if (!column.name) {
-          continue;
-        }
-        const count = colmap.get(column.name) || 0;
-        if (count > 0) {
-          column.name = `${column.name}_${count + 1}`;
-        }
-        colmap.set(column.name, count + 1);
-      }
-
-      const lowerName = query.name[0].toLowerCase() + query.name.slice(1);
+      for (const query of queries) {
+        const lowerName = query.name[0].toLowerCase() + query.name.slice(1);
       const textName = `${lowerName}Query`;
 
       nodes.push(
@@ -158,11 +148,28 @@ ${query.text}`
       let returnIface = undefined;
       if (query.params.length > 0) {
         argIface = `${query.name}Args`;
-        nodes.push(argsDecl(argIface, driver, query.params));
+        nodes.push(
+          argsDecl({
+            name: argIface,
+            driver,
+            params: query.params,
+            queryName: query.name,
+            fileName: filename,
+          })
+        );
       }
       if (query.columns.length > 0) {
         returnIface = `${query.name}Row`;
-        nodes.push(rowDecl(returnIface, driver, query.columns));
+        nodes.push(
+          rowDecl({
+            name: returnIface,
+            driver,
+            columns: query.columns,
+            queryName: query.name,
+            fileName: filename,
+          })
+        );
+        nodes.push(rowValuesDecl(`${returnIface}Values`, driver, query.columns));
       }
 
       switch (query.cmd) {
@@ -244,43 +251,63 @@ function queryDecl(name: string, sql: string) {
   );
 }
 
-function argsDecl(
-  name: string,
-  driver: Driver,
-  params: Parameter[]
-) {
+function argsDecl(options: {
+  name: string;
+  driver: Driver;
+  params: Parameter[];
+  queryName: string;
+  fileName: string;
+}) {
+  const names = options.params.map((param, i) => argName(i, param.column));
+  assertUniqueNames({
+    kind: "argument",
+    queryName: options.queryName,
+    fileName: options.fileName,
+    names,
+  });
+
   return factory.createInterfaceDeclaration(
     [factory.createToken(SyntaxKind.ExportKeyword)],
-    factory.createIdentifier(name),
+    factory.createIdentifier(options.name),
     undefined,
     undefined,
-    params.map((param, i) =>
+    options.params.map((param, i) =>
       factory.createPropertySignature(
         undefined,
         factory.createIdentifier(argName(i, param.column)),
         undefined,
-        driver.columnType(param.column)
+        options.driver.columnType(param.column)
       )
     )
   );
 }
 
-function rowDecl(
-  name: string,
-  driver: Driver,
-  columns: Column[]
-) {
+function rowDecl(options: {
+  name: string;
+  driver: Driver;
+  columns: Column[];
+  queryName: string;
+  fileName: string;
+}) {
+  const names = options.columns.map((column, i) => colName(i, column));
+  assertUniqueNames({
+    kind: "column",
+    queryName: options.queryName,
+    fileName: options.fileName,
+    names,
+  });
+
   return factory.createInterfaceDeclaration(
     [factory.createToken(SyntaxKind.ExportKeyword)],
-    factory.createIdentifier(name),
+    factory.createIdentifier(options.name),
     undefined,
     undefined,
-    columns.map((column, i) =>
+    options.columns.map((column, i) =>
       factory.createPropertySignature(
         undefined,
         factory.createIdentifier(colName(i, column)),
         undefined,
-        driver.columnType(column)
+        options.driver.columnType(column)
       )
     )
   );

src/app.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from "bun:test";
+import {
+  createPrinter,
+  createSourceFile,
+  EmitHint,
+  NewLineKind,
+  ScriptKind,
+  ScriptTarget,
+} from "typescript";
+
+import { rowValuesDecl } from "./decls";
+import { Driver as BunSqlDriver } from "./drivers/bun-sql";
+import type { Column } from "./gen/plugin/codegen_pb";
+
+function print(node: unknown): string {
+  const source = createSourceFile(
+    "file.ts",
+    "",
+    ScriptTarget.Latest,
+    false,
+    ScriptKind.TS
+  );
+  const printer = createPrinter({ newLine: NewLineKind.LineFeed });
+  // @ts-expect-error printer expects a ts.Node
+  return printer.printNode(EmitHint.Unspecified, node, source);
+}
+
+describe("rowValuesDecl", () => {
+  it("emits an exported tuple type", () => {
+    const driver = new BunSqlDriver();
+    const columns: Column[] = [
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      ({ name: "id", type: { name: "text" } } as unknown as Column),
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      ({ name: "created_at", type: { name: "timestamptz" } } as unknown as Column),
+    ];
+
+    const node = rowValuesDecl("ExampleRowValues", driver, columns);
+    const output = print(node);
+
+    expect(output).toContain("export type ExampleRowValues");
+    expect(output).toContain("string | null");
+    expect(output).toContain("Date | null");
+  });
+});

src/decls.test.ts

@@ -0,0 +1,22 @@
+import { SyntaxKind, TypeNode, factory } from "typescript";
+
+import type { Column } from "./gen/plugin/codegen_pb";
+
+export interface ColumnTyper {
+  columnType: (c?: Column) => TypeNode;
+}
+
+export function rowValuesDecl(name: string, driver: ColumnTyper, columns: Column[]) {
+  return factory.createTypeAliasDeclaration(
+    [factory.createToken(SyntaxKind.ExportKeyword)],
+    factory.createIdentifier(name),
+    undefined,
+    factory.createTupleTypeNode(columns.map((c) => driver.columnType(c)))
+  );
+}
+
+export function arrayOfTypeRef(name: string) {
+  return factory.createArrayTypeNode(
+    factory.createTypeReferenceNode(factory.createIdentifier(name), undefined)
+  );
+}