true-pg 0.4.5 → 0.5.1

package/lib/kysely/index.js

@@ -1,155 +1,148 @@
 import { Canonical, FunctionReturnTypeKind, } from "../extractor/index.js";
-import { allowed_kind_names, createGenerator, Nodes } from "../types.js";
+import { allowed_kind_names, createGenerator } from "../types.js";
+import { Import } from "../imports.js";
 import { builtins } from "./builtins.js";
-import { join, quote, quoteI } from "../util.js";
-const toPascalCase = (str) => str
-    .replace(/^[^a-zA-Z]+/, "") // remove leading non-alphabetic characters
-    .replace(/[^a-zA-Z0-9_]+/g, "") // remove non-alphanumeric/underscore characters
-    .replace(" ", "_") // replace spaces with underscores
-    .replace(/_([a-z])/g, (_, letter) => letter.toUpperCase()) // capitalize letters after underscores
-    .replace(/^([a-z])/, (_, letter) => letter.toUpperCase()); // capitalize first letter
+import { toPascalCase, join, quote, quoteI } from "../util.js";
 export const Kysely = createGenerator(opts => {
     const defaultSchema = opts?.defaultSchema ?? "public";
-    const ky = (imports, name) => imports.add(new Nodes.ExternalImport({
-        name,
-        module: "kysely",
-        typeOnly: true,
-        star: false,
-    }));
-    const add = (imports, type) => {
-        if (type.schema === "pg_catalog")
-            return;
-        imports.add(new Nodes.InternalImport({
-            name: generator.formatType(type),
-            canonical_type: type,
+    const ky = (ctx, name) => {
+        ctx.imports.add(new Import({
+            from: "kysely",
+            namedImports: [name],
             typeOnly: true,
-            star: false,
         }));
     };
     const column = (
     /** "this" */
-    generator, 
-    /** @out Append used types to this array */
-    imports, 
+    generator, ctx, 
     /** Information about the column */
     col) => {
-        let base = generator.formatType(col.type);
-        if (col.type.dimensions > 0)
-            base += "[]".repeat(col.type.dimensions);
-        if (col.isNullable)
-            base += " | null";
+        let base = generator.formatType(ctx, col.type, { nullable: col.isNullable });
         let qualified = base;
         if (col.generated === "ALWAYS") {
             qualified = `GeneratedAlways<${qualified}>`;
-            ky(imports, "GeneratedAlways");
+            ky(ctx, "GeneratedAlways");
         }
         else if (col.generated === "BY DEFAULT") {
             qualified = `Generated<${qualified}>`;
-            ky(imports, "Generated");
+            ky(ctx, "Generated");
         }
         else if (col.defaultValue) {
             qualified = `Generated<${qualified}>`;
-            ky(imports, "Generated");
+            ky(ctx, "Generated");
         }
         let out = col.comment ? `/** ${col.comment} */\n\t` : "";
         out += quoteI(col.name);
         // TODO: update imports for non-primitive types
         out += `: ${qualified}`;
-        add(imports, col.type);
         return `\t${out};\n`;
     };
-    const composite_attribute = (generator, imports, attr) => {
+    const composite_attribute = (ctx, generator, attr) => {
         let out = quoteI(attr.name);
         if (attr.isNullable)
             out += "?";
-        out += `: ${generator.formatType(attr.type)}`;
-        add(imports, attr.type);
-        if (attr.type.dimensions > 0)
-            out += "[]".repeat(attr.type.dimensions);
-        if (attr.isNullable)
-            out += " | null";
+        out += ": ";
+        out += generator.formatType(ctx, attr.type, { nullable: attr.isNullable });
         return out;
     };
     const generator = {
-        formatSchema(name) {
+        formatSchemaName(name) {
             return toPascalCase(name) + "Schema";
         },
-        formatSchemaType(type) {
+        formatSchemaMemberName(type) {
             return toPascalCase(type.name);
         },
-        formatType(type) {
+        formatType(ctx, type, attr) {
+            let base;
             if (type.kind === FunctionReturnTypeKind.ExistingTable) {
-                return toPascalCase(type.name);
+                base = toPascalCase(type.name);
             }
             else if (type.schema === "pg_catalog") {
                 const name = type.canonical_name;
                 const format = builtins[name];
                 if (format)
-                    return format;
-                opts?.warnings?.push(`(kysely) Unknown builtin type: ${name}. Pass customBuiltinMap to map this type. Defaulting to "unknown".`);
-                return "unknown";
+                    base = format;
+                else {
+                    opts?.warnings?.add(`(kysely) Unknown builtin type: ${name}. Pass 'kysely.builtinMap' to map this type. Defaulting to "unknown".`);
+                    base = "unknown";
+                }
             }
-            return toPascalCase(type.name);
+            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,
+                    withName: base,
+                    typeOnly: true,
+                }));
+            }
+            if ("dimensions" in type)
+                base += "[]".repeat(type.dimensions);
+            if (attr?.nullable)
+                base += " | null";
+            return base;
         },
-        table(imports, table) {
+        table(ctx, table) {
             let out = "";
             if (table.comment)
                 out += `/** ${table.comment} */\n`;
-            out += `export interface ${this.formatSchemaType(table)} {\n`;
+            out += `export interface ${this.formatSchemaMemberName(table)} {\n`;
             for (const col of table.columns)
-                out += column(this, imports, col);
+                out += column(this, ctx, col);
             out += "}";
             return out;
         },
-        view(imports, view) {
+        view(ctx, view) {
             let out = "";
             if (view.comment)
                 out += `/** ${view.comment} */\n`;
-            out += `export interface ${this.formatSchemaType(view)} {\n`;
+            out += `export interface ${this.formatSchemaMemberName(view)} {\n`;
             for (const col of view.columns)
-                out += column(this, imports, col);
+                out += column(this, ctx, col);
             out += "}";
             return out;
         },
-        materializedView(imports, materializedView) {
+        materializedView(ctx, materializedView) {
             let out = "";
             if (materializedView.comment)
                 out += `/** ${materializedView.comment} */\n`;
-            out += `export interface ${this.formatSchemaType(materializedView)} {\n`;
+            out += `export interface ${this.formatSchemaMemberName(materializedView)} {\n`;
             for (const col of materializedView.columns)
-                out += column(this, imports, col);
+                out += column(this, ctx, col);
             out += "}";
             return out;
         },
-        enum(imports, en) {
+        enum(ctx, en) {
             let out = "";
             if (en.comment)
                 out += `/** ${en.comment} */\n`;
-            out += `export type ${this.formatSchemaType(en)} = ${en.values.map(v => `"${v}"`).join(" | ")};`;
+            out += `export type ${this.formatSchemaMemberName(en)} = ${en.values.map(v => `"${v}"`).join(" | ")};`;
             return out;
         },
-        composite(imports, type) {
+        composite(ctx, type) {
             let out = "";
             if (type.comment)
                 out += `/** ${type.comment} */\n`;
-            out += `export interface ${this.formatSchemaType(type)} {\n`;
-            const props = type.canonical.attributes.map(c => composite_attribute(this, imports, c)).map(t => `\t${t};`);
+            out += `export interface ${this.formatSchemaMemberName(type)} {\n`;
+            const props = type.canonical.attributes.map(c => composite_attribute(ctx, this, c)).map(t => `\t${t};`);
             out += props.join("\n");
             out += "\n}";
             return out;
         },
-        domain(imports, type) {
+        domain(ctx, type) {
             let out = "";
-            out += `export type ${this.formatSchemaType(type)} = ${this.formatType(type.canonical.domain_base_type)};`;
+            out += `export type ${this.formatSchemaMemberName(type)} = ${this.formatType(ctx, type.canonical.domain_base_type)};`;
             return out;
         },
-        range(imports, type) {
+        range(ctx, type) {
             let out = "";
             // force this to be string because range has to be passed as a string to Kysely
-            out += `export type ${this.formatSchemaType(type)} = string;`;
+            out += `export type ${this.formatSchemaMemberName(type)} = string;`;
             return out;
         },
-        function(imports, type) {
+        function(ctx, type) {
             let out = "";
             out += "/**\n";
             if (type.comment)
@@ -158,7 +151,7 @@ export const Kysely = createGenerator(opts => {
             out += ` * @parallelSafety ${type.parallelSafety}\n`;
             out += ` * @isStrict ${type.isStrict}\n`;
             out += " */\n";
-            out += `export interface ${this.formatSchemaType(type)} {\n\t`;
+            out += `export interface ${this.formatSchemaMemberName(type)} {\n\t`;
             // Get the input parameters (those that appear in function signature)
             const inputParams = type.parameters.filter(p => p.mode === "IN" || p.mode === "INOUT" || p.mode === "VARIADIC");
             if (inputParams.length === 0) {
@@ -168,10 +161,7 @@ export const Kysely = createGenerator(opts => {
                 out += "(";
                 out += inputParams[0].name;
                 out += ": ";
-                out += this.formatType(inputParams[0].type);
-                add(imports, inputParams[0].type);
-                if (inputParams[0].type.dimensions > 0)
-                    out += "[]".repeat(inputParams[0].type.dimensions);
+                out += this.formatType(ctx, inputParams[0].type);
                 out += "): ";
             }
             else if (inputParams.length > 0) {
@@ -183,10 +173,7 @@ export const Kysely = createGenerator(opts => {
                     out += `\t\t${paramName}`;
                     if (param.hasDefault && !isVariadic)
                         out += "?";
-                    out += `: ${this.formatType(param.type)}`;
-                    add(imports, param.type);
-                    if (param.type.dimensions > 0)
-                        out += "[]".repeat(param.type.dimensions);
+                    out += `: ${this.formatType(ctx, param.type)}`;
                     if (!isVariadic)
                         out += ",";
                     out += "\n";
@@ -200,24 +187,17 @@ export const Kysely = createGenerator(opts => {
                     out += "{\n";
                     for (const col of type.returnType.columns) {
                         out += `\t\t"${col.name}": `;
-                        out += this.formatType(col.type);
-                        add(imports, col.type);
-                        if (col.type.dimensions > 0)
-                            out += "[]".repeat(col.type.dimensions);
+                        out += this.formatType(ctx, col.type);
                         out += `;\n`;
                     }
                     out += "\t}";
                 }
             }
             else if (type.returnType.kind === FunctionReturnTypeKind.ExistingTable) {
-                out += this.formatType(type.returnType);
-                add(imports, type.returnType);
+                out += this.formatType(ctx, type.returnType);
             }
             else {
-                out += this.formatType(type.returnType.type);
-                add(imports, type.returnType.type);
-                if (type.returnType.type.dimensions > 0)
-                    out += "[]".repeat(type.returnType.type.dimensions);
+                out += this.formatType(ctx, type.returnType.type);
             }
             // Add additional array brackets if it returns a set
             if (type.returnType.isSet) {
@@ -226,24 +206,25 @@ export const Kysely = createGenerator(opts => {
             out += ";\n}";
             return out;
         },
-        schemaKindIndex(schema, kind, main_generator) {
+        schemaKindIndex(ctx, schema, kind, main_generator) {
             const generator = main_generator ?? this;
             const imports = schema[kind];
             if (imports.length === 0)
                 return "";
             return imports
                 .map(each => {
-                const name = this.formatSchemaType(each);
-                const file = generator.formatSchemaType(each);
+                const name = generator.formatSchemaMemberName(each);
+                const file = generator.formatSchemaMemberName(each);
                 return `export type { ${name} } from "./${file}.ts";`;
             })
                 .join("\n");
         },
-        schemaIndex(schema) {
+        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");
             out += "\n\n";
-            out += `export interface ${this.formatSchema(schema.name)} {\n`;
+            out += `export interface ${this.formatSchemaName(schema.name)} {\n`;
             for (const kind of actual_kinds) {
                 const items = schema[kind];
                 if (items.length === 0)
@@ -251,7 +232,7 @@ export const Kysely = createGenerator(opts => {
                 out += `\t${kind}: {\n`;
                 const formatted = items
                     .map(each => {
-                    const formatted = this.formatSchemaType(each);
+                    const formatted = generator.formatSchemaMemberName(each);
                     return { ...each, formatted };
                 })
                     .filter(x => x !== undefined);
@@ -266,10 +247,10 @@ export const Kysely = createGenerator(opts => {
             out += "}";
             return out;
         },
-        fullIndex(schemas) {
+        fullIndex(ctx, schemas) {
             const parts = [];
             parts.push(schemas
-                .map(s => `import type { ${this.formatSchema(s.name)} } from "./${s.name}/index.ts";`)
+                .map(s => `import type { ${generator.formatSchemaName(s.name)} } from "./${s.name}/index.ts";`)
                 .join("\n"));
             {
                 let iface = `export interface Database {\n`;
@@ -281,7 +262,7 @@ export const Kysely = createGenerator(opts => {
                     const seen = new Set();
                     const formatted = tables
                         .map(each => {
-                        const formatted = this.formatSchemaType(each);
+                        const formatted = generator.formatSchemaMemberName(each);
                         // skip clashing names
                         if (seen.has(formatted))
                             return;
@@ -300,7 +281,7 @@ export const Kysely = createGenerator(opts => {
                         else
                             qualified = t.name;
                         qualified = quoteI(qualified);
-                        return `\t${qualified}: ${this.formatSchema(schema.name)}[${quote(t.kind + "s")}][${quote(t.name)}];`;
+                        return `\t${qualified}: ${generator.formatSchemaName(schema.name)}[${quote(t.kind + "s")}][${quote(t.name)}];`;
                     })
                         .join("\n");
                     return out;
@@ -309,7 +290,7 @@ export const Kysely = createGenerator(opts => {
                 iface += "\n}";
                 parts.push(iface);
             }
-            parts.push(schemas.map(s => `export type { ${this.formatSchema(s.name)} };`).join("\n"));
+            parts.push(schemas.map(s => `export type { ${generator.formatSchemaName(s.name)} };`).join("\n"));
             return join(parts);
         },
     };

package/lib/types.d.ts

@@ -1,4 +1,5 @@
 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 type allowed_kind_names = (typeof allowed_kind_names)[number];
 export interface FolderStructure {
@@ -23,118 +24,72 @@ export interface FolderStructure {
         };
     };
 }
-export declare namespace Nodes {
-    class ExternalImport {
-        name: string;
-        typeOnly: boolean;
-        star: boolean;
-        external: true;
-        module: string;
-        constructor(args: {
-            name: string;
-            module: string;
-            typeOnly: boolean;
-            star: boolean;
-        });
-    }
-    class InternalImport {
-        name: string;
-        canonical_type: Canonical | FunctionReturnType.ExistingTable;
-        typeOnly: boolean;
-        star: boolean;
-        external: false;
-        constructor(args: {
-            name: string;
-            canonical_type: Canonical | FunctionReturnType.ExistingTable;
-            typeOnly: boolean;
-            star: boolean;
-        });
-    }
-    class ImportList {
-        imports: (ExternalImport | InternalImport)[];
-        constructor(imports: (ExternalImport | InternalImport)[]);
-        static merge(lists: ImportList[]): ImportList;
-        add(item: ExternalImport | InternalImport): void;
-        stringify(context_file: string, files: FolderStructure): string;
-    }
-    interface Export {
-        name: string;
-        kind: SchemaType["kind"];
-        schema: string;
-        star: boolean;
-    }
-}
 export interface CreateGeneratorOpts {
     defaultSchema?: string;
-    warnings: string[];
+    warnings: Set<string>;
 }
 export interface createGenerator {
     (opts?: CreateGeneratorOpts): SchemaGenerator;
 }
 export declare const createGenerator: (generatorCreator: createGenerator) => createGenerator;
+export interface GeneratorContext {
+    /** The source file path */
+    source: string;
+    /** Append types to import */
+    imports: ImportList;
+}
+export interface FormatTypeAttributes {
+    nullable?: boolean;
+    generated?: boolean;
+    identity?: boolean;
+}
 export interface SchemaGenerator {
     /**
      * Use this function to define a name mapping for schema names.
      * This is useful if you want to use a different name for a schema in the generated code.
      * Example: "public" -> "PublicSchema"
      */
-    formatSchema(name: string): string;
+    formatSchemaName(name: string): string;
     /**
-     * Use this function to define a name mapping for schema types.
-     * This is useful if you want to use a different name for a type in the generated code.
+     * Use this function to define a name mapping for schema members.
+     * This is useful if you want to use a different name for a member in the generated code.
      * Example: "users" -> "UsersTable"
      */
-    formatSchemaType(type: SchemaType): string;
+    formatSchemaMemberName(type: SchemaType): string;
     /**
      * Use this function to define a name mapping for type names.
      * This is useful if you want to use a different name for a type in the generated code.
      * Example: "users" -> "UsersTable"
      */
-    formatType(type: Canonical | FunctionReturnType.ExistingTable): string;
-    table(
-    /** @out Append used types to this array */
-    imports: Nodes.ImportList, 
+    formatType(ctx: GeneratorContext, type: Canonical | FunctionReturnType.ExistingTable, attr?: FormatTypeAttributes): string;
+    table(ctx: GeneratorContext, 
     /** Information about the table */
     table: TableDetails): string;
-    view(
-    /** @out Append used types to this array */
-    imports: Nodes.ImportList, 
+    view(ctx: GeneratorContext, 
     /** Information about the view */
     view: ViewDetails): string;
-    materializedView(
-    /** @out Append used types to this array */
-    imports: Nodes.ImportList, 
+    materializedView(ctx: GeneratorContext, 
     /** Information about the materialized view */
     materializedView: MaterializedViewDetails): string;
-    enum(
-    /** @out Append used types to this array */
-    imports: Nodes.ImportList, 
+    enum(ctx: GeneratorContext, 
     /** Information about the enum */
     en: EnumDetails): string;
-    composite(
-    /** @out Append used types to this array */
-    imports: Nodes.ImportList, 
+    composite(ctx: GeneratorContext, 
     /** Information about the composite type */
     type: CompositeTypeDetails): string;
-    domain(
-    /** @out Append used types to this array */
-    imports: Nodes.ImportList, 
+    domain(ctx: GeneratorContext, 
     /** Information about the domain */
     type: DomainDetails): string;
-    range(
-    /** @out Append used types to this array */
-    imports: Nodes.ImportList, 
+    range(ctx: GeneratorContext, 
     /** Information about the range */
     type: RangeDetails): string;
-    function(
-    /** @out Append used types to this array */
-    imports: Nodes.ImportList, 
+    function(ctx: GeneratorContext, 
     /** Information about the function */
     type: FunctionDetails): string;
     /** create the file `$out/$schema.name/$kind/index.ts` */
-    schemaKindIndex(schema: Schema, kind: Exclude<keyof Schema, "name">, main_generator?: SchemaGenerator): string;
+    schemaKindIndex(ctx: GeneratorContext, schema: Schema, kind: Exclude<keyof Schema, "name">, main_generator?: SchemaGenerator): string;
     /** create the file `$out/$schema.name/index.ts` */
-    schemaIndex(schema: Schema, main_generator?: SchemaGenerator): string;
+    schemaIndex(ctx: GeneratorContext, schema: Schema, main_generator?: SchemaGenerator): string;
     /** create the file `$out/index.ts` */
-    fullIndex(schemas: Schema[], main_generator?: SchemaGenerator): string;
+    fullIndex(ctx: GeneratorContext, schemas: Schema[], main_generator?: SchemaGenerator): string;
 }