true-pg 0.5.0 → 0.6.0

package/lib/types.d.ts

@@ -1,5 +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";
-export declare const allowed_kind_names: readonly ["tables", "views", "materializedViews", "enums", "composites", "functions", "domains", "ranges"];
+import type { ImportList } from "./imports.ts";
+export declare const allowed_kind_names: ("function" | "enum" | "domain" | "range" | "table" | "view" | "materializedView" | "composite")[];
 export type allowed_kind_names = (typeof allowed_kind_names)[number];
 export interface FolderStructure {
     name: string;
@@ -9,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]: {
@@ -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;
 }

package/lib/types.js

@@ -1,179 +1,5 @@
-import { Canonical, } from "./extractor/index.js";
-import { dirname, relative } from "node:path/posix";
-import { join } from "./util.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 var Nodes;
-(function (Nodes) {
-    class ExternalImport {
-        // what to import
-        name;
-        // use `type` syntax?
-        typeOnly;
-        // use `* as` syntax?
-        star;
-        // this is an external import
-        external;
-        // what module to import from
-        module;
-        constructor(args) {
-            this.name = args.name;
-            this.typeOnly = args.typeOnly;
-            this.star = args.star;
-            this.external = true;
-            this.module = args.module;
-        }
-    }
-    Nodes.ExternalImport = ExternalImport;
-    class InternalImport {
-        // what to import
-        name;
-        // underlying type that is being imported
-        canonical_type;
-        // use `type` syntax?
-        typeOnly;
-        // use `* as` syntax?
-        star;
-        // this is an internal import
-        external;
-        constructor(args) {
-            this.name = args.name;
-            this.canonical_type = args.canonical_type;
-            this.star = args.star;
-            this.typeOnly = args.typeOnly;
-            this.external = false;
-        }
-    }
-    Nodes.InternalImport = InternalImport;
-    class ImportList {
-        imports;
-        constructor(imports) {
-            this.imports = imports;
-        }
-        static merge(lists) {
-            return new ImportList(lists.flatMap(l => l.imports));
-        }
-        add(item) {
-            this.imports.push(item);
-        }
-        stringify(context_file, files) {
-            const externals = this.imports.filter(i => i.external);
-            const internals = this.imports.filter(i => !i.external);
-            const modulegroups = {};
-            for (const item of externals) {
-                const group = modulegroups[item.module];
-                if (group)
-                    group.push(item);
-                else
-                    modulegroups[item.module] = [item];
-            }
-            const out = [];
-            // TODO: normalise external and internal imports and handle the stringification of the imports in a single place
-            {
-                // EXTERNAL IMPORTS
-                const imports = [];
-                for (const module in modulegroups) {
-                    const items = modulegroups[module];
-                    const star = items.find(i => i.star);
-                    const unique = items.filter((i, index, arr) => {
-                        if (i.star)
-                            return false;
-                        if (arr.findIndex(i2 => i2.name === i.name) !== index)
-                            return false;
-                        return true;
-                    });
-                    const bits = [];
-                    const typeOnlys = unique.filter(i => i.typeOnly);
-                    const values = unique.filter(i => !i.typeOnly);
-                    // if no values to import, use `import type { ... }` instead of `import { type ... }`
-                    const typeInline = values.length !== 0;
-                    let import_line = `import `;
-                    for (const type of typeOnlys)
-                        bits.push(typeInline ? "type " : "" + type.name);
-                    for (const type of values)
-                        bits.push(type.name);
-                    if (bits.length)
-                        import_line += (typeInline ? "" : "type ") + "{ " + bits.join(", ") + " }";
-                    if (bits.length && star)
-                        import_line += `, `;
-                    if (star)
-                        import_line += `* as ${star.name}`;
-                    if (bits.length || star)
-                        import_line += ` from `;
-                    import_line += `"${module}";`;
-                    imports.push(import_line);
-                }
-                out.push(join(imports, "\n"));
-            }
-            {
-                // INTERNAL IMPORTS
-                const imports = [];
-                const unique_types = internals
-                    .filter(({ name: name1, canonical_type: int }, index, arr) => {
-                    return (arr.findIndex(({ name: name2, canonical_type: int2 }) => {
-                        return (
-                        // adapter-assigned name
-                        name2 === name1 &&
-                            // canonical type details
-                            int2.name === int.name &&
-                            int2.schema === int.schema &&
-                            int2.kind === int.kind);
-                    }) === index);
-                })
-                    .filter(imp => imp.canonical_type.kind === Canonical.Kind.Base ||
-                    allowed_kind_names.includes(`${imp.canonical_type.kind}s`))
-                    .map(imp => {
-                    const t = imp.canonical_type;
-                    const schema = files.children[t.schema];
-                    const kind = schema.children[`${t.kind}s`];
-                    const type = kind.children[t.name];
-                    const located_file = `${files.name}/${schema.name}/${kind.kind}/${type.name}.ts`;
-                    return { ...imp, located_file };
-                });
-                const group_by_file = {};
-                for (const type of unique_types) {
-                    const file = group_by_file[type.located_file] || [];
-                    file.push(type);
-                    group_by_file[type.located_file] = file;
-                }
-                for (const group in group_by_file) {
-                    let relative_path = relative(dirname(context_file), group);
-                    if (/^[^\.+\/]/.test(relative_path))
-                        relative_path = "./" + relative_path;
-                    const items = group_by_file[group];
-                    const typeOnlys = items.filter(i => i.typeOnly);
-                    const values = items.filter(i => !i.typeOnly);
-                    const star = values.find(i => i.star);
-                    let import_line = "import ";
-                    const bits = [];
-                    // if no values to import, use `import type { ... }` instead of `import { type ... }`
-                    const typeInline = values.length !== 0;
-                    for (const type of typeOnlys)
-                        bits.push((typeInline ? "type " : "") + type.name);
-                    for (const type of values)
-                        bits.push(type.name);
-                    if (bits.length)
-                        import_line += (typeInline ? "" : "type ") + "{ " + bits.join(", ") + " }";
-                    if (star)
-                        import_line += `* as ${star.name}`;
-                    import_line += ` from "${relative_path}";`;
-                    imports.push(import_line);
-                }
-                out.push(join(imports, "\n"));
-            }
-            return join(out);
-        }
-    }
-    Nodes.ImportList = ImportList;
-})(Nodes || (Nodes = {}));
+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,4 @@
+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;
 export declare const join: (parts: Iterable<string>, joiner?: string) => string;
@@ -9,6 +10,7 @@ export type Deunionise<B extends object | undefined, T = B> = Simplify<T extends
 export type Simplify<T> = {
     [KeyType in keyof T]: T[KeyType];
 } & {};
+export declare const parens: (str: string, type?: string) => string;
 export declare const quote: (str: string, using?: string) => string;
 export declare const quoteI: (str: string, using?: string) => string;
 export {};

package/lib/util.js

@@ -1,3 +1,15 @@
+export const eq = (a, b) => {
+    if (a === b)
+        return true;
+    if (a == null || b == null)
+        return false;
+    if (typeof a !== "object" || typeof b !== "object")
+        return false;
+    for (const key in a)
+        if (!eq(a[key], b[key]))
+            return false;
+    return true;
+};
 export const toPascalCase = (str) => {
     let result = "";
     let index = 0;
@@ -113,5 +125,6 @@ const isIdentifierInvalid = (str) => {
     const invalid = str.match(/[^a-zA-Z0-9_]/);
     return invalid !== null;
 };
+export const parens = (str, type = "()") => `${type[0]}${str}${type[1]}`;
 export const quote = (str, using = '"') => `${using}${str.replaceAll(using, "\\" + using)}${using}`;
 export const quoteI = (str, using = '"') => (isIdentifierInvalid(str) ? quote(str, using) : str);