true-pg 0.5.1 → 0.7.0

package/lib/kysely/index.js

@@ -31,9 +31,10 @@ export const Kysely = createGenerator(opts => {
             qualified = `Generated<${qualified}>`;
             ky(ctx, "Generated");
         }
+        // TODO: Use ColumnType for appropriate cases:
+        // composite, jsonb, json, date types, etc
         let out = col.comment ? `/** ${col.comment} */\n\t` : "";
         out += quoteI(col.name);
-        // TODO: update imports for non-primitive types
         out += `: ${qualified}`;
         return `\t${out};\n`;
     };
@@ -56,21 +57,27 @@ export const Kysely = createGenerator(opts => {
             let base;
             if (type.kind === FunctionReturnTypeKind.ExistingTable) {
                 base = toPascalCase(type.name);
+                ctx.imports.add(Import.fromInternal({
+                    source: ctx.source,
+                    type,
+                    withName: base,
+                    typeOnly: true,
+                }));
             }
-            else if (type.schema === "pg_catalog") {
+            else if (type.schema === "pg_catalog" ||
+                type.kind === Canonical.Kind.Base ||
+                type.kind === Canonical.Kind.Pseudo) {
                 const name = type.canonical_name;
                 const format = builtins[name];
                 if (format)
                     base = format;
                 else {
-                    opts?.warnings?.add(`(kysely) Unknown builtin type: ${name}. Pass 'kysely.builtinMap' to map this type. Defaulting to "unknown".`);
+                    opts?.warnings?.add(`(kysely) Unknown base type: ${name}. Pass 'kysely.builtinMap' to map this type. Defaulting to "unknown".`);
                     base = "unknown";
                 }
             }
-            else
+            else {
                 base = toPascalCase(type.name);
-            if (type.schema !== "pg_catalog") {
-                // before adding modifiers, add the import
                 ctx.imports.add(Import.fromInternal({
                     source: ctx.source,
                     type,
@@ -222,14 +229,14 @@ export const Kysely = createGenerator(opts => {
         schemaIndex(ctx, schema) {
             const actual_kinds = allowed_kind_names.filter(kind => schema[kind].length);
             // we could in theory use the imports from GeneratorContext here, but this works fine
-            let out = actual_kinds.map(kind => `import type * as ${kind} from "./${kind}/index.ts";`).join("\n");
+            let out = actual_kinds.map(kind => `import type * as ${kind}s from "./${kind}s/index.ts";`).join("\n");
             out += "\n\n";
             out += `export interface ${this.formatSchemaName(schema.name)} {\n`;
             for (const kind of actual_kinds) {
                 const items = schema[kind];
                 if (items.length === 0)
                     continue;
-                out += `\t${kind}: {\n`;
+                out += `\t${kind}s: {\n`;
                 const formatted = items
                     .map(each => {
                     const formatted = generator.formatSchemaMemberName(each);
@@ -257,7 +264,7 @@ export const Kysely = createGenerator(opts => {
                 iface += schemas
                     .map(schema => {
                     // only tables, views, and materialized views are queryable
-                    const tables = [...schema.tables, ...schema.views, ...schema.materializedViews];
+                    const tables = [...schema.table, ...schema.view, ...schema.materializedView];
                     let out = "";
                     const seen = new Set();
                     const formatted = tables

package/lib/types.d.ts

@@ -1,6 +1,6 @@
 import { Canonical, type TableDetails, type ViewDetails, type MaterializedViewDetails, type EnumDetails, type CompositeTypeDetails, type DomainDetails, type RangeDetails, type FunctionDetails, type SchemaType, type Schema, type FunctionReturnType } from "./extractor/index.ts";
 import type { ImportList } from "./imports.ts";
-export declare const allowed_kind_names: readonly ["tables", "views", "materializedViews", "enums", "composites", "functions", "domains", "ranges"];
+export declare const allowed_kind_names: ("function" | "composite" | "domain" | "enum" | "range" | "table" | "view" | "materializedView")[];
 export type allowed_kind_names = (typeof allowed_kind_names)[number];
 export interface FolderStructure {
     name: string;
@@ -10,8 +10,8 @@ export interface FolderStructure {
             name: string;
             type: "schema";
             children: {
-                [kind: string]: {
-                    kind: allowed_kind_names;
+                [kind in allowed_kind_names]: {
+                    kind: kind;
                     type: "kind";
                     children: {
                         [realname: string]: {

package/lib/types.js

@@ -1,14 +1,5 @@
-import { Canonical, } from "./extractor/index.js";
+import { Canonical, pgTypeKinds, } from "./extractor/index.js";
 // To be updated when we add support for other kinds
-export const allowed_kind_names = [
-    "tables",
-    "views",
-    "materializedViews",
-    "enums",
-    "composites",
-    "functions",
-    "domains",
-    "ranges",
-];
+export const allowed_kind_names = pgTypeKinds;
 /* convenience function to create a generator with type inference */
 export const createGenerator = (generatorCreator) => generatorCreator;

package/lib/util.d.ts

@@ -1,3 +1,10 @@
+export declare const unreachable: (value: never) => never;
+export declare class Deferred<T> {
+    resolve: (value: T) => void;
+    reject: (reason?: any) => void;
+    promise: Promise<T>;
+    constructor();
+}
 export declare const eq: <T>(a: T, b: T) => boolean;
 export declare const toPascalCase: (str: string) => string;
 export declare const to_snake_case: (str: string) => string;

package/lib/util.js

@@ -1,3 +1,17 @@
+export const unreachable = (value) => {
+    throw new Error(`Fatal: Reached unreachable code: ${value}`);
+};
+export class Deferred {
+    resolve;
+    reject;
+    promise;
+    constructor() {
+        this.promise = new Promise((resolve, reject) => {
+            this.resolve = resolve;
+            this.reject = reject;
+        });
+    }
+}
 export const eq = (a, b) => {
     if (a === b)
         return true;

package/lib/zod/index.js

@@ -1,4 +1,4 @@
-import { FunctionReturnTypeKind, } from "../extractor/index.js";
+import { Canonical, FunctionReturnTypeKind, } from "../extractor/index.js";
 import { allowed_kind_names, createGenerator } from "../types.js";
 import { Import } from "../imports.js";
 import { builtins } from "./builtins.js";
@@ -22,16 +22,12 @@ export const Zod = createGenerator(opts => {
         out += quoteI(col.name);
         const nullable = col.isNullable || col.generated === "BY DEFAULT" || col.defaultValue;
         let type = generator.formatType(ctx, col.type, { nullable });
-        if (nullable)
-            type += `.optional()`;
         out += `: ${type}`;
         return `\t${out},\n`;
     };
     const composite_attribute = (ctx, attr) => {
         let out = quoteI(attr.name);
         out += `: ${generator.formatType(ctx, attr.type, { nullable: attr.isNullable })}`;
-        if (attr.isNullable)
-            out += ".optional()";
         return out;
     };
     const generator = {
@@ -45,27 +41,31 @@ export const Zod = createGenerator(opts => {
             let base;
             if (type.kind === FunctionReturnTypeKind.ExistingTable) {
                 base = to_snake_case(type.name);
+                ctx.imports.add(Import.fromInternal({
+                    source: ctx.source,
+                    type,
+                    withName: base,
+                    typeOnly: false,
+                }));
             }
-            else if (type.schema === "pg_catalog") {
+            else if (type.schema === "pg_catalog" ||
+                type.kind === Canonical.Kind.Base ||
+                type.kind === Canonical.Kind.Pseudo) {
                 const name = type.canonical_name;
                 const format = builtins[name];
                 if (format)
                     base = format;
                 else {
-                    opts?.warnings?.add(`(zod) Unknown builtin type: ${name}. Pass 'zod.builtinMap' to map this type. Defaulting to "z.unknown()".`);
+                    opts?.warnings?.add(`(zod) Unknown base type: ${name}. Pass 'zod.builtinMap' to map this type. Defaulting to "z.unknown()".`);
                     base = "z.unknown()";
                 }
-            }
-            else
-                base = to_snake_case(type.name);
-            if (type.schema === "pg_catalog") {
                 ctx.imports.add(new Import({
                     from: "zod",
                     namedImports: ["z"],
                 }));
             }
             else {
-                // before adding modifiers, add the import
+                base = to_snake_case(type.name);
                 ctx.imports.add(Import.fromInternal({
                     source: ctx.source,
                     type,
@@ -76,7 +76,7 @@ export const Zod = createGenerator(opts => {
             if ("dimensions" in type)
                 base += ".array()".repeat(type.dimensions);
             if (attr?.nullable)
-                base += ".nullable()";
+                base += ".optional()";
             return base;
         },
         table(ctx, table) {
@@ -159,8 +159,6 @@ export const Zod = createGenerator(opts => {
                 for (const param of inputParams) {
                     // TODO: update imports for non-primitive types based on typeInfo.kind
                     out += "\t\t" + this.formatType(ctx, param.type, { nullable: param.hasDefault });
-                    if (param.hasDefault)
-                        out += ".optional()";
                     out += `, // ${param.name}\n`;
                 }
                 out += "\t])";
@@ -217,14 +215,14 @@ export const Zod = createGenerator(opts => {
         schemaIndex(ctx, schema, main_generator) {
             const actual_kinds = allowed_kind_names.filter(kind => schema[kind].length);
             // we could in theory use the imports from GeneratorContext here, but this works fine
-            let out = actual_kinds.map(kind => `import * as zod_${kind} from "./${kind}/index.ts";`).join("\n");
+            let out = actual_kinds.map(kind => `import * as zod_${kind}s from "./${kind}s/index.ts";`).join("\n");
             out += "\n\n";
             out += `export const ${this.formatSchemaName(schema.name)} = {\n`;
             for (const kind of actual_kinds) {
                 const items = schema[kind];
                 if (items.length === 0)
                     continue;
-                out += `\t${kind}: {\n`;
+                out += `\t${kind}s: {\n`;
                 const formatted = items
                     .map(each => {
                     const formatted = this.formatSchemaMemberName(each);
@@ -245,9 +243,7 @@ export const Zod = createGenerator(opts => {
         fullIndex(ctx, schemas, main_generator) {
             const generator = main_generator ?? this;
             const parts = [];
-            parts.push(schemas
-                .map(s => `import { ${generator.formatSchemaName(s.name)} } from "./${s.name}/index.ts";`)
-                .join("\n"));
+            parts.push(schemas.map(s => `import { ${generator.formatSchemaName(s.name)} } from "./${s.name}/index.ts";`).join("\n"));
             {
                 let validator = `export const Validators = {\n`;
                 validator += join(schemas.map(schema => {
@@ -267,7 +263,7 @@ export const Zod = createGenerator(opts => {
                         if (!formatted.length)
                             return "";
                         let out = "";
-                        out += "\t// " + kind + "\n";
+                        out += "\t// " + kind + "s\n";
                         out += join(formatted.map(t => {
                             const isDefault = defaultSchema === schema.name;
                             let qualified = "";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "true-pg",
-	"version": "0.5.1",
+	"version": "0.7.0",
 	"type": "module",
 	"module": "lib/index.js",
 	"main": "lib/index.js",