true-pg 0.5.1 → 0.6.0

package/lib/extractor/index.d.ts

@@ -9,6 +9,7 @@ import { type FunctionDetails } from "./kinds/function.ts";
 import { type DomainDetails } from "./kinds/domain.ts";
 import { type RangeDetails } from "./kinds/range.ts";
 import type { PgType } from "./pgtype.ts";
+export { pgTypeKinds, type PgType, type Kind } from "./pgtype.ts";
 import { Canonical } from "./canonicalise.ts";
 export { Canonical };
 export type { TableDetails, ViewDetails, MaterializedViewDetails, EnumDetails, CompositeTypeDetails, FunctionDetails, DomainDetails, RangeDetails, };
@@ -23,14 +24,14 @@ export { FunctionReturnTypeKind } from "./kinds/function.ts";
  */
 export type Schema = {
     name: string;
-    tables: TableDetails[];
-    views: ViewDetails[];
-    materializedViews: MaterializedViewDetails[];
-    enums: EnumDetails[];
-    composites: CompositeTypeDetails[];
-    functions: FunctionDetails[];
-    domains: DomainDetails[];
-    ranges: RangeDetails[];
+    table: TableDetails[];
+    view: ViewDetails[];
+    materializedView: MaterializedViewDetails[];
+    enum: EnumDetails[];
+    composite: CompositeTypeDetails[];
+    function: FunctionDetails[];
+    domain: DomainDetails[];
+    range: RangeDetails[];
 };
 export type SchemaType = TableDetails | ViewDetails | MaterializedViewDetails | EnumDetails | CompositeTypeDetails | FunctionDetails | DomainDetails | RangeDetails;
 /**

package/lib/extractor/index.js

@@ -10,18 +10,19 @@ import extractFunction, {} from "./kinds/function.js";
 import extractDomain, {} from "./kinds/domain.js";
 import extractRange, {} from "./kinds/range.js";
 import fetchTypes from "./fetchTypes.js";
+export { pgTypeKinds } from "./pgtype.js";
 import { canonicalise, Canonical } from "./canonicalise.js";
 export { Canonical };
 export { FunctionReturnTypeKind } from "./kinds/function.js";
 const emptySchema = {
-    tables: [],
-    views: [],
-    materializedViews: [],
-    enums: [],
-    composites: [],
-    functions: [],
-    domains: [],
-    ranges: [],
+    table: [],
+    view: [],
+    materializedView: [],
+    enum: [],
+    composite: [],
+    function: [],
+    domain: [],
+    range: [],
 };
 const populatorMap = {
     table: extractTable,
@@ -133,10 +134,7 @@ export class Extractor {
                     ...emptySchema,
                 };
             }
-            schemas[p.schemaName][`${p.kind}s`] = [
-                ...schemas[p.schemaName][`${p.kind}s`],
-                p,
-            ];
+            schemas[p.schemaName][p.kind] = [...schemas[p.schemaName][p.kind], p];
         }
         const result = 
         //  options?.resolveViews

package/lib/extractor/pgtype.d.ts

@@ -1,9 +1,9 @@
 export declare const typeKindMap: {
-    readonly d: "domain";
     readonly e: "enum";
+    readonly d: "domain";
     readonly r: "range";
 };
-type TypeKind = (typeof typeKindMap)[keyof typeof typeKindMap];
+export type TypeKind = (typeof typeKindMap)[keyof typeof typeKindMap];
 export declare const classKindMap: {
     readonly r: "table";
     readonly p: "table";
@@ -11,12 +11,13 @@ export declare const classKindMap: {
     readonly m: "materializedView";
     readonly c: "composite";
 };
-type ClassKind = (typeof classKindMap)[keyof typeof classKindMap];
+export type ClassKind = (typeof classKindMap)[keyof typeof classKindMap];
 export declare const routineKindMap: {
     readonly f: "function";
 };
-type RoutineKind = (typeof routineKindMap)[keyof typeof routineKindMap];
-export type Kind = TypeKind | ClassKind | RoutineKind;
+export type RoutineKind = (typeof routineKindMap)[keyof typeof routineKindMap];
+export declare const pgTypeKinds: ("function" | "enum" | "domain" | "range" | "table" | "view" | "materializedView" | "composite")[];
+export type Kind = (typeof pgTypeKinds)[number];
 /**
  * Base type for Postgres objects.
  */
@@ -38,4 +39,3 @@ export type PgType<K extends Kind = Kind> = {
      */
     comment: string | null;
 };
-export {};

package/lib/extractor/pgtype.js

@@ -1,6 +1,6 @@
 export const typeKindMap = {
-    d: "domain",
     e: "enum",
+    d: "domain",
     r: "range",
     // Not supported (yet):
     // m: 'multiRange',
@@ -28,3 +28,9 @@ export const routineKindMap = {
     // a: 'aggregate',
     // w: 'windowFunction',
 };
+const unique = (arr) => [...new Set(arr)];
+export const pgTypeKinds = unique([
+    ...Object.values(classKindMap),
+    ...Object.values(typeKindMap),
+    ...Object.values(routineKindMap),
+]);

package/lib/imports.d.ts

@@ -1,11 +1,16 @@
 import type { Canonical } from "./extractor/index.ts";
 import type { FunctionReturnType } from "./extractor/index.ts";
-import type { FolderStructure } from "./types.ts";
+import type { allowed_kind_names, FolderStructure } from "./types.ts";
 export interface ImportIdentifier {
     name: string;
     alias?: string;
     typeOnly?: boolean;
 }
+type Supported<T> = {
+    [key in allowed_kind_names]: T extends {
+        kind: key;
+    } ? T : never;
+}[allowed_kind_names];
 export declare class Import {
     from: string | ((files: FolderStructure) => string);
     namedImports?: (string | ImportIdentifier)[];
@@ -21,7 +26,7 @@ export declare class Import {
     });
     static fromInternal(opts: {
         source: string;
-        type: Canonical | FunctionReturnType.ExistingTable;
+        type: Supported<Canonical | FunctionReturnType.ExistingTable>;
         withName?: string;
         typeOnly?: boolean;
     }): Import;
@@ -33,3 +38,4 @@ export declare class ImportList {
     add(item: Import): void;
     stringify(files: FolderStructure): string;
 }
+export {};

package/lib/imports.js

@@ -18,9 +18,9 @@ export class Import {
         return new Import({
             from: files => {
                 const schema = files.children[t.schema];
-                const kind = schema.children[`${t.kind}s`];
+                const kind = schema.children[t.kind];
                 const type = kind.children[t.name];
-                const path = `${files.name}/${schema.name}/${kind.kind}/${type.name}.ts`;
+                const path = `${files.name}/${schema.name}/${kind.kind}s/${type.name}.ts`;
                 return relative(dirname(opts.source), path);
             },
             namedImports: [opts.withName ?? t.name],

package/lib/index.js

@@ -115,9 +115,9 @@ const multifile = async (generators, schemas, opts) => {
     for (const schema of Object.values(schemas)) {
         console.log("Selected schema '%s':\n", schema.name);
         const schemaDir = joinpath(out, schema.name);
-        const [unique_functions, overloaded_functions] = filter_overloaded_functions(schema.functions);
+        const [unique_functions, overloaded_functions] = filter_overloaded_functions(schema.function);
         const [supported_functions, unsupported_functions] = filter_unsupported_functions(unique_functions);
-        schema.functions = supported_functions;
+        schema.function = supported_functions;
         {
             const skipped = unsupported_functions.map(f => `  - ${f.name}`);
             if (skipped.length) {
@@ -136,11 +136,12 @@ const multifile = async (generators, schemas, opts) => {
             if (schema[kind].length < 1)
                 continue;
             createIndex = true;
-            await mkdir(joinpath(schemaDir, kind), { recursive: true });
-            console.log(" Creating %s:\n", kind);
+            const kindDir = joinpath(schemaDir, kind + "s");
+            await mkdir(kindDir, { recursive: true });
+            console.log(" Creating %s:\n", kind + "s");
             for (const [i, item] of schema[kind].entries()) {
                 const index = "[" + (i + 1 + "]").padEnd(3, " ");
-                const filename = joinpath(schemaDir, kind, def_gen.formatSchemaMemberName(item) + ".ts");
+                const filename = joinpath(kindDir, def_gen.formatSchemaMemberName(item) + ".ts");
                 const exists = await existsSync(filename);
                 if (exists) {
                     warnings.add(`Skipping ${item.kind} "${item.name}": formatted name clashes. Wanted to create ${filename}`);
@@ -159,7 +160,7 @@ const multifile = async (generators, schemas, opts) => {
             {
                 const start = performance.now();
                 const imports = new ImportList();
-                const fileName = joinpath(schemaDir, kind, "index.ts");
+                const fileName = joinpath(kindDir, "index.ts");
                 const kindIndex = join(gens.map(gen => gen.schemaKindIndex({ source: fileName, imports }, schema, kind, def_gen)));
                 const file = join([imports.stringify(files), kindIndex]);
                 await write(fileName, file);

package/lib/kysely/index.js

@@ -33,7 +33,6 @@ export const Kysely = createGenerator(opts => {
         }
         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 +55,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 +227,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 +262,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" | "enum" | "domain" | "range" | "table" | "view" | "materializedView" | "composite")[];
 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/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";
@@ -45,27 +45,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,
@@ -217,14 +221,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);
@@ -267,7 +271,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.6.0",
 	"type": "module",
 	"module": "lib/index.js",
 	"main": "lib/index.js",