@technicity/data-service-generator 0.23.0-next.1 → 0.23.0-next.11

package/dist/generation/generate.d.ts

@@ -9,6 +9,9 @@ type IGenerateInput = {
     host?: string;
     port?: number;
     server?: string;
+    clientOpts?: {
+        [k: string]: any;
+    };
     outdir: string;
     tables?: Array<string>;
     excludeTables?: Array<string>;
@@ -16,6 +19,7 @@ type IGenerateInput = {
     includeMappedFields?: IIncludeMappedFields;
     supplementClientOpts?: ISupplementClientOpts;
     outputSqliteSchema?: boolean;
+    logLevel?: string;
 };
 export declare function generate(input: IGenerateInput): Promise<void>;
 export {};

package/dist/generation/generate.js

@@ -33,6 +33,7 @@ const os = __importStar(require("node:os"));
 const node_async_hooks_1 = require("node:async_hooks");
 const child_process = __importStar(require("node:child_process"));
 const node_crypto_1 = __importDefault(require("node:crypto"));
+const pino_1 = require("pino");
 const prettier = __importStar(require("prettier"));
 const changeCase = __importStar(require("change-case"));
 const fse = __importStar(require("fs-extra"));
@@ -44,6 +45,7 @@ const isNotNullOrUndefined_1 = require("../lib/isNotNullOrUndefined");
 const pg_1 = require("pg");
 const MySQL_1 = require("../runtime/lib/MySQL");
 const capitalizeFirstLetter_1 = require("../lib/capitalizeFirstLetter");
+const pg2sqliteSchema_1 = require("./pg2sqliteSchema");
 const ctxStorage = new node_async_hooks_1.AsyncLocalStorage();
 function getCtx() {
     const c = ctxStorage.getStore();
@@ -62,17 +64,38 @@ async function generate(input) {
     if (input.dialect == null) {
         throw new Error("Must specify `dialect`");
     }
+    const log = (0, pino_1.pino)({
+        name: "generate",
+        level: input.logLevel ?? process.env.LOG_LEVEL ?? "info",
+        transport: {
+            target: "pino-pretty",
+            options: {
+                colorize: true
+            }
+        }
+    });
     const specialCaseUuidColumn = input.specialCaseUuidColumn ?? true;
     const includeMappedFields = input.includeMappedFields ?? true;
     const supplementClientOpts = input.supplementClientOpts ?? true;
+    const runId = node_crypto_1.default.randomUUID();
     const ctx = {
-        runId: node_crypto_1.default.randomUUID(),
+        runId,
+        log: log.child({}),
         dialect: input.dialect,
-        query: undefined
+        query: undefined,
+        pool: undefined
     };
+    log.debug({
+        runId: ctx.runId,
+        dialect: input.dialect,
+        database: input.database,
+        outdir: input.outdir
+    }, "generate() started");
     return ctxStorage.run(ctx, async () => {
         init(input);
+        ctx.log.debug("init() completed");
         let tables = await getTableNames();
+        ctx.log.debug({ tableCount: tables.length, tables }, "getTableNames() completed");
         if (tables.length === 0) {
             throw new Error("No tables found");
         }
@@ -82,19 +105,23 @@ async function generate(input) {
         if (input.excludeTables != null) {
             tables = tables.filter((x) => !input.excludeTables?.includes(x));
         }
+        ctx.log.debug({ tableCount: tables.length, tables }, "tables after filter");
         const data = await Promise.all(tables.flatMap((x) => [
-            getGetOneData(x, includeMappedFields),
+            getGetOneData(x, includeMappedFields, tables),
             getGetListData(x),
             getGetListPaginatedData(x),
-            getPostOneData(x, specialCaseUuidColumn, includeMappedFields),
+            getPostOneData(x, specialCaseUuidColumn, includeMappedFields, tables),
             getPatchOneData(x, specialCaseUuidColumn, includeMappedFields),
             getPatchListData(x),
             getDeleteOneData(x),
             getDeleteListData(x)
         ]));
+        ctx.log.debug({ inputLength: data.length }, "SDK input data collected");
         const artifacts = await getArtifacts(tables, includeMappedFields, specialCaseUuidColumn);
+        ctx.log.debug("getArtifacts() completed");
         const artifactsSource = getArtifactsSource(artifacts);
         const sdkSource = await getSDKSource(data, specialCaseUuidColumn, supplementClientOpts, artifacts, input.outputSqliteSchema);
+        ctx.log.debug("getSDKSource() completed");
         const sdkFilename = "index.ts";
         const sourceIRuntimeFilePath = fs.existsSync(path.join(__dirname, "../runtime", "IRuntime.ts"))
             ? path.join(__dirname, "../runtime", "IRuntime.ts")
@@ -129,6 +156,7 @@ async function generate(input) {
         const tmpDirPath = path.join(os.tmpdir(), 
         // _ because - in filename is not supported by mysql2sqlite
         `dsg_${node_crypto_1.default.randomUUID()}`.replace(/-/g, "_"));
+        ctx.log.debug({ tmpDirPath }, "writing SDK and artifacts to tmp dir");
         fse.mkdirpSync(tmpDirPath);
         fs.writeFileSync(path.join(tmpDirPath, sdkFilename), sdkSource);
         fs.writeFileSync(path.join(tmpDirPath, artifactsFilename), artifactsSource);
@@ -174,67 +202,99 @@ async function generate(input) {
         fs.writeFileSync(path.join(tmpBuildOutputPath, "IRuntime.d.ts"), fs.existsSync(path.join(__dirname, "../runtime", "IRuntime.d.ts"))
             ? fs.readFileSync(path.join(__dirname, "../runtime", "IRuntime.d.ts"), "utf-8")
             : fs.readFileSync(sourceIRuntimeFilePath, "utf-8"));
-        if (getCtx().dialect === "mysql" && input.outputSqliteSchema) {
-            // Since mysql2sqlite outputs a malformed string if a column
-            // has the name `enum`, temporarily change the name to something else,
-            // then change it back.
-            const enumMarker = "`" + node_crypto_1.default.randomUUID() + "`";
-            const schemaMySql = Object.values(artifacts)
-                .reduce((acc, x) => {
-                let d = x.dump?.schema;
-                if (!d) {
+        if (input.outputSqliteSchema) {
+            let schemaSqlite = null;
+            if (ctx.dialect === "mysql") {
+                // Since mysql2sqlite outputs a malformed string if a column
+                // has the name `enum`, temporarily change the name to something else,
+                // then change it back.
+                const enumMarker = "`" + node_crypto_1.default.randomUUID() + "`";
+                const schemaMySql = Object.values(artifacts)
+                    .reduce((acc, x) => {
+                    let d = x.dump?.schema;
+                    if (!d) {
+                        return acc;
+                    }
+                    d = d.replace(/`enum`/g, enumMarker);
+                    d += ";";
+                    acc.push(d);
                     return acc;
-                }
-                d = d.replace(/`enum`/g, enumMarker);
-                d += ";";
-                acc.push(d);
-                return acc;
-            }, [])
-                .join("\n\n");
-            const mysql2SqliteSrc = getMysql2sqliteSrc();
-            const mysql2SqlitePath = path.join(tmpDirPath, "mysql2sqlite");
-            fs.writeFileSync(mysql2SqlitePath, mysql2SqliteSrc);
-            fs.chmodSync(mysql2SqlitePath, 0o755);
-            const tmpMySqlSchemaFilename = "tmp.sql";
-            const tmpMySqlSchemaPath = path.join(tmpDirPath, tmpMySqlSchemaFilename);
-            fs.writeFileSync(tmpMySqlSchemaPath, schemaMySql);
-            let schemaSqlite = child_process
-                .execFileSync(mysql2SqlitePath, [tmpMySqlSchemaFilename], { cwd: tmpDirPath })
-                .toString();
-            schemaSqlite = schemaSqlite.replace(new RegExp(enumMarker, "g"), "`enum`");
-            const src = prettier.format(`module.exports = { schema: \`${schemaSqlite.replace(/`/g, "\\`")}\` }`, { parser: "babel" });
-            fs.writeFileSync(path.join(tmpBuildOutputPath, "artifacts.sqlite.js"), src);
+                }, [])
+                    .join("\n\n");
+                const mysql2SqliteSrc = getMysql2sqliteSrc();
+                const mysql2SqlitePath = path.join(tmpDirPath, "mysql2sqlite");
+                fs.writeFileSync(mysql2SqlitePath, mysql2SqliteSrc);
+                fs.chmodSync(mysql2SqlitePath, 0o755);
+                const tmpMySqlSchemaFilename = "tmp.sql";
+                const tmpMySqlSchemaPath = path.join(tmpDirPath, tmpMySqlSchemaFilename);
+                fs.writeFileSync(tmpMySqlSchemaPath, schemaMySql);
+                schemaSqlite = child_process
+                    .execFileSync(mysql2SqlitePath, [tmpMySqlSchemaFilename], {
+                    cwd: tmpDirPath
+                })
+                    .toString();
+                schemaSqlite = schemaSqlite.replace(new RegExp(enumMarker, "g"), "`enum`");
+            }
+            else if (ctx.dialect === "postgresql") {
+                schemaSqlite = await (0, pg2sqliteSchema_1.convertPgSchemaToSqlite)(ctx.pool);
+            }
+            if (schemaSqlite) {
+                const src = prettier.format(`module.exports = { schema: \`${schemaSqlite.replace(/`/g, "\\`")}\` }`, { parser: "babel" });
+                fs.writeFileSync(path.join(tmpBuildOutputPath, "artifacts.sqlite.js"), src);
+            }
         }
         if (!fs.existsSync(outdir)) {
             fse.mkdirpSync(outdir);
         }
         fse.emptyDirSync(sdkOutputPath);
         fse.copySync(tmpBuildOutputPath, sdkOutputPath);
+        ctx.log.debug({ outdir, sdkOutputPath }, "copy to output dir completed");
         fse.removeSync(tmpDirPath);
+        ctx.log.debug("generate() completed");
     });
 }
 function init(input) {
     const ctx = getCtx();
     const { database, user, password, host, port, server } = input;
     if (ctx.dialect === "mysql") {
-        const mysql = new MySQL_1.MySQL({
+        const connectionOpts = {
             user,
             password,
-            host,
-            port,
-            database
-        });
+            host: host ?? "localhost",
+            port: port ?? 3306,
+            database,
+            ...input.clientOpts
+        };
+        ctx.log.debug({
+            dialect: "mysql",
+            host: connectionOpts.host,
+            port: connectionOpts.port,
+            database,
+            user
+        }, "connecting to MySQL");
+        const mysql = new MySQL_1.MySQL(connectionOpts);
         ctx.query = mysql.query.bind(mysql);
+        ctx.pool = mysql;
     }
     if (ctx.dialect === "postgresql") {
-        const pool = new pg_1.Pool({
+        const connectionOpts = {
             host: host ?? "localhost",
             port: port ?? 5432,
             user,
             password,
-            database
-        });
+            database,
+            ...input.clientOpts
+        };
+        ctx.log.debug({
+            dialect: "postgresql",
+            host: connectionOpts.host,
+            port: connectionOpts.port,
+            database,
+            user
+        }, "connecting to PostgreSQL");
+        const pool = new pg_1.Pool(connectionOpts);
         ctx.query = (q, values) => pool.query(q, values ?? []).then((r) => r.rows);
+        ctx.pool = pool;
     }
 }
 // It's a bit awkward to put __whereNeedsProcessing, __prepareWhere on the class,
@@ -278,7 +338,7 @@ async function getSDKSource(input, specialCaseUuidColumn, supplementClientOpts,
       runtime: any;
       clientOpts: { [k: string]: any; },
       otherOpts?: { [k: string]: any; },
-      passBeforeValueToAfterCallback: boolean,
+      passBeforeValueToAfterCallback?: boolean,
      }) {
       let otherOpts = opts.otherOpts ?? {};
       if (opts.clientOpts.filename === ":memory:") {
@@ -291,7 +351,7 @@ async function getSDKSource(input, specialCaseUuidColumn, supplementClientOpts,
         : "otherOpts"}, artifacts);
       this.onHandlerMap = new Map();
       this.eventTarget = new EventTarget();
-      this.passBeforeValueToAfterCallback = opts.passBeforeValueToAfterCallback;
+      this.passBeforeValueToAfterCallback = opts.passBeforeValueToAfterCallback ?? false;
     }
 
     $use(middleware: TMiddleware) {
@@ -621,6 +681,7 @@ function getMethodSourceOnHandlerPostOne(x) {
     return `on${(0, capitalizeFirstLetter_1.capitalizeFirstLetter)(x.methodName)}(handler:
     (sdk: InstanceType<typeof SDK>, input: { data: ${x.typeDataName} },
     output: Partial<${getTypeReturnName(x.table)}>,
+    before: null,
     context: TContext,
   ) => Promise<void>
 ): void {
@@ -735,6 +796,7 @@ function getMethodSourceOnHandlerDeleteOne(x, findOnes) {
         .map((findOne) => `{ ${findOne.name}: ${findOne.type}${findOne.nullable ? " | null" : ""} }`)
         .join(" | ")}, },
     output: void,
+    before: ${getTypeReturnName(x.table)} | null,
     context: TContext,
   ) => Promise<void>
 ): void {
@@ -822,16 +884,16 @@ function getTypeOrderByName(table) {
 function getTypeDataPostName(table) {
     return "DataPost" + changeCase.pascalCase(table);
 }
-async function getGetOneData(table, includeMappedFields) {
+async function getGetOneData(table, includeMappedFields, tables) {
     const typeFieldsName = getTypeFieldsName(table);
     const typeReturnBaseName = getTypeReturnBaseName(table);
     return {
         kind: "getOne",
         table,
         methodName: "get" + changeCase.pascalCase(table),
-        typeFields: await getTypeFields(table, typeFieldsName, includeMappedFields),
+        typeFields: await getTypeFields(table, typeFieldsName, includeMappedFields, tables),
         typeFieldsName,
-        typeReturnBase: await getTypeReturnBase(table, typeReturnBaseName, includeMappedFields),
+        typeReturnBase: await getTypeReturnBase(table, typeReturnBaseName, includeMappedFields, tables),
         typeReturnBaseName
     };
 }
@@ -869,7 +931,7 @@ async function getGetListPaginatedData(table) {
         typeOrderByName
     };
 }
-async function getPostOneData(table, specialCaseUuidColumn, includeMappedFields) {
+async function getPostOneData(table, specialCaseUuidColumn, includeMappedFields, tables) {
     const typeFieldsName = getTypeFieldsName(table);
     const typeReturnBaseName = getTypeReturnBaseName(table);
     const typeDataName = getTypeDataPostName(table);
@@ -879,7 +941,7 @@ async function getPostOneData(table, specialCaseUuidColumn, includeMappedFields)
         methodName: "post" + changeCase.pascalCase(table),
         typeFieldsName,
         typeReturnBaseName,
-        typeData: await getTypeDataPost(table, typeDataName, specialCaseUuidColumn, includeMappedFields),
+        typeData: await getTypeDataPost(table, typeDataName, specialCaseUuidColumn, includeMappedFields, tables),
         typeDataName
     };
 }
@@ -934,7 +996,7 @@ async function getTypeWhere(table, name) {
     const jsonSchemaWhere = await getJSONSchemaWhere(table);
     return (0, json_schema_to_typescript_1.compile)(jsonSchemaWhere, name, json2TsOpts);
 }
-async function getTypeDataPost(table, name, specialCaseUuidColumn, includeMappedFields) {
+async function getTypeDataPost(table, name, specialCaseUuidColumn, includeMappedFields, tables) {
     const primaryColumn = await getPrimaryColumn(table);
     const tableMeta = (await getTableMeta(table)).filter((x) => x.Field !== primaryColumn.name);
     const nullable = tableMeta.reduce((acc, m) => ({
@@ -947,7 +1009,7 @@ async function getTypeDataPost(table, name, specialCaseUuidColumn, includeMapped
     }), {});
     let properties = getJSONSchemaObjProperties(tableMeta);
     let notRequiredList = [];
-    const oneToManyRelations = (await getRelationInfo(table)).filter((x) => x.type === "one-to-many__many-to-one" && x.kind === "one-to-many");
+    const oneToManyRelations = (await getRelationInfo(table, tables)).filter((x) => x.type === "one-to-many__many-to-one" && x.kind === "one-to-many");
     const mappedFields = includeMappedFields ? await getMappedFields(table) : [];
     let mappedFieldsMap = new Map();
     if (includeMappedFields) {
@@ -1328,9 +1390,9 @@ export type TUpdateOperationsNumber = {$increment: number} | {$decrement: number
 `;
     return prettier.format(src, { parser: "typescript" });
 }
-async function getTypeFields(table, name, includeMappedFields) {
+async function getTypeFields(table, name, includeMappedFields, tables) {
     const scalarKeys = Object.keys(getJSONSchemaObjProperties(await getTableMeta(table)));
-    const relations = await getRelationInfo(table);
+    const relations = await getRelationInfo(table, tables);
     const mappedFields = includeMappedFields ? await getMappedFields(table) : [];
     const keyWhere = "$where";
     const keyOrderBy = "$orderBy";
@@ -1390,10 +1452,10 @@ async function getTypeFields(table, name, includeMappedFields) {
     type = imports + "\n\n" + type;
     return type;
 }
-async function getTypeReturnBase(table, name, includeMappedFields) {
+async function getTypeReturnBase(table, name, includeMappedFields, tables) {
     const tableMeta = await getTableMeta(table);
     const scalarProperties = getJSONSchemaObjProperties(tableMeta);
-    const relations = await getRelationInfo(table);
+    const relations = await getRelationInfo(table, tables);
     const mappedFields = includeMappedFields ? await getMappedFields(table) : [];
     const jsonSchemaReturn = {
         type: "object",
@@ -1444,6 +1506,7 @@ function getArtifactsSource(artifacts) {
     return prettier.format(src, { parser: "typescript" });
 }
 async function getArtifacts(tables, includeMappedFields, specialCaseUuidColumn) {
+    const ctx = getCtx();
     const tableMetaList = await Promise.all(tables.map(async (table) => {
         const [tableMeta, primaryKey, dumpSchema] = await Promise.all([
             getTableMeta(table),
@@ -1451,7 +1514,7 @@ async function getArtifacts(tables, includeMappedFields, specialCaseUuidColumn)
             getShowCreateTable(table)
         ]);
         const scalarFields = tableMeta.map((x) => x.Field);
-        const relationInfo = await getRelationInfo(table);
+        const relationInfo = await getRelationInfo(table, tables);
         const relationFields = relationInfo.reduce((acc, x) => {
             if (x.type === "one-to-many__many-to-one") {
                 acc[x.name] = {
@@ -1509,7 +1572,7 @@ async function getArtifacts(tables, includeMappedFields, specialCaseUuidColumn)
             }
             return {
                 kind: "scalar",
-                type: getBaseJSONType(t.Type, getCtx().dialect),
+                type: getBaseJSONType(t.Type, ctx.dialect),
                 name: t.Field,
                 nullable,
                 hasDefaultValue: !!t.Default
@@ -1554,7 +1617,7 @@ async function getArtifacts(tables, includeMappedFields, specialCaseUuidColumn)
     }, {});
     return artifacts;
 }
-const getRelationInfo = (0, memoize_1.default)(async function getRelationInfo(table) {
+const getRelationInfo = (0, memoize_1.default)(async function getRelationInfo(table, tables) {
     const relationsManyToOne = await getRelationsManyToOne(table);
     const relationsOneToMany = await getRelationsOneToMany(table);
     let out = [];
@@ -1601,7 +1664,7 @@ const getRelationInfo = (0, memoize_1.default)(async function getRelationInfo(ta
         });
         return acc;
     }, []));
-    const relationsManyToMany = (await getJunctionTables()).reduce((acc, x) => {
+    const relationsManyToMany = (await getJunctionTables(tables)).reduce((acc, x) => {
         const dataForParentTable = x.relations.find((r) => r.referencedTable === table);
         if (dataForParentTable == null) {
             return acc;
@@ -1622,15 +1685,14 @@ const getRelationInfo = (0, memoize_1.default)(async function getRelationInfo(ta
         return acc;
     }, []);
     out = out.concat(relationsManyToMany);
-    out = _.sortBy((x) => x.table, out);
+    out = _.sortBy([(x) => x.table, (x) => x.name], out);
     return out;
 }, (table) => getCtx().runId + ":" + table);
 function getRelationManyToOneFieldName(x) {
     return changeCase.camelCase(x.foreignKey.replace(new RegExp(x.referencedKey + "$", "i"), ""));
 }
 // TODO: not sure if this logic is correct
-async function getJunctionTables() {
-    const tables = await getTableNames();
+const getJunctionTables = (0, memoize_1.default)(async function getJunctionTables(tables) {
     return (await Promise.all(tables.map(async (table) => {
         const relations = await getRelationsManyToOne(table);
         if (relations.length === 2 &&
@@ -1644,7 +1706,7 @@ async function getJunctionTables() {
         }
         return null;
     }))).filter(isNotNullOrUndefined_1.isNotNullOrUndefined);
-}
+}, () => getCtx().runId);
 // `from` relations
 // https://stackoverflow.com/a/54732547
 const getRelationsManyToOne = (0, memoize_1.default)(async function getRelationsManyToOne(table) {
@@ -1674,7 +1736,8 @@ const getRelationsManyToOne = (0, memoize_1.default)(async function getRelations
        FROM information_schema.key_column_usage kcu
        JOIN information_schema.referential_constraints rc ON kcu.constraint_name = rc.constraint_name AND kcu.table_schema = rc.constraint_schema
        JOIN information_schema.constraint_column_usage ccu ON rc.unique_constraint_name = ccu.constraint_name AND rc.unique_constraint_schema = ccu.table_schema
-       WHERE kcu.table_schema = 'public' AND kcu.table_name = $1`, [table]);
+       WHERE kcu.table_schema = 'public' AND kcu.table_name = $1
+       ORDER BY ccu.table_name, ccu.column_name`, [table]);
     }
     else {
         throw new Error("Unsupported dialect: " + dialect);
@@ -1688,7 +1751,7 @@ const getRelationsManyToOne = (0, memoize_1.default)(async function getRelations
             nullable: tableMeta.find((m) => m.Field === v.t1Field)?.Null === "YES"
         };
     })));
-    return _.sortBy((x) => x.referencedTable, xs);
+    return _.sortBy([(x) => x.referencedTable, (x) => x.referencedKey, (x) => x.foreignKey], xs);
 }, (table) => getCtx().runId + ":" + table);
 // `to` relations
 const getRelationsOneToMany = (0, memoize_1.default)(async function getRelationsOneToMany(table) {
@@ -1717,7 +1780,8 @@ const getRelationsOneToMany = (0, memoize_1.default)(async function getRelations
        FROM information_schema.key_column_usage kcu
        JOIN information_schema.referential_constraints rc ON kcu.constraint_name = rc.constraint_name AND kcu.table_schema = rc.constraint_schema
        JOIN information_schema.constraint_column_usage ccu ON rc.unique_constraint_name = ccu.constraint_name AND rc.unique_constraint_schema = ccu.table_schema
-       WHERE kcu.table_schema = 'public' AND ccu.table_name = $1`, [table]);
+       WHERE kcu.table_schema = 'public' AND ccu.table_name = $1
+       ORDER BY kcu.table_name, kcu.column_name`, [table]);
     }
     else {
         throw new Error("Unsupported dialect: " + dialect);
@@ -1731,7 +1795,7 @@ const getRelationsOneToMany = (0, memoize_1.default)(async function getRelations
             nullable: false
         };
     })));
-    return _.sortBy((x) => x.referencedKey, _.sortBy((x) => x.referencedTable, xs));
+    return _.sortBy([(x) => x.referencedTable, (x) => x.referencedKey, (x) => x.foreignKey], xs);
 }, (table) => getCtx().runId + ":" + table);
 async function getPrimaryColumn(table) {
     const tableMeta = await getTableMeta(table);
@@ -1770,27 +1834,29 @@ async function getUuidColumn(table) {
         nullable: column.Null === "YES"
     };
 }
-const getPgEnumDefinition = (0, memoize_1.default)(async function getPgEnumDefinition(udtName) {
+const getPgEnumDefinition = (0, memoize_1.default)(async function getPgEnumDefinition(udtSchema, udtName) {
     const { dialect, query } = getCtx();
     if (dialect !== "postgresql")
         return null;
     const rows = await query(`SELECT e.enumlabel FROM pg_enum e
      JOIN pg_type t ON e.enumtypid = t.oid
      JOIN pg_catalog.pg_namespace n ON t.typnamespace = n.oid
-     WHERE t.typname = $1 AND n.nspname = 'public'
-     ORDER BY e.enumsortorder`, [udtName]);
+     WHERE t.typname = $2 AND n.nspname = $1
+     ORDER BY e.enumsortorder`, [udtSchema, udtName]);
     if (rows.length === 0)
         return null;
     const labels = rows.map((r) => String(r.enumlabel).replace(/'/g, "''"));
     return "enum('" + labels.join("', '") + "')";
-}, (udtName) => getCtx().runId + ":" + udtName);
+}, (udtSchema, udtName) => getCtx().runId + ":" + udtSchema + ":" + udtName);
 const getTableMeta = (0, memoize_1.default)(async function getTableMeta(table) {
-    const { dialect, query } = getCtx();
+    const ctx = getCtx();
+    const { dialect, query } = ctx;
+    ctx.log.debug({ table }, "getTableMeta() fetching");
     if (dialect === "mysql") {
         return query("DESCRIBE ??", [table]).then((xs) => _.sortBy((x) => x.Field, xs));
     }
     if (dialect === "postgresql") {
-        const columns = await query(`SELECT column_name AS "Field", data_type, udt_name, character_maximum_length AS char_max, is_nullable, column_default AS "Default"
+        const columns = await query(`SELECT column_name AS "Field", data_type, udt_schema, udt_name, character_maximum_length AS char_max, is_nullable, column_default AS "Default"
        FROM information_schema.columns
        WHERE table_schema = 'public' AND table_name = $1
        ORDER BY ordinal_position`, [table]);
@@ -1815,17 +1881,26 @@ const getTableMeta = (0, memoize_1.default)(async function getTableMeta(table) {
             if (!keyMap.has(k.col) || k.key_type === "PRI")
                 keyMap.set(k.col, k.key_type);
         }
-        const udtNames = [
-            ...new Set(columns
-                .filter((c) => c.data_type === "USER-DEFINED" && c.udt_name != null)
-                .map((c) => c.udt_name))
+        const udtKeys = [
+            ...new Map(columns
+                .filter((c) => c.data_type === "USER-DEFINED" &&
+                c.udt_schema != null &&
+                c.udt_name != null)
+                .map((c) => [`${c.udt_schema}.${c.udt_name}`, c])).keys()
         ];
-        const enumDefs = await Promise.all(udtNames.map((udt) => getPgEnumDefinition(udt)));
-        const enumMap = new Map(udtNames.map((udt, i) => [udt, enumDefs[i] ?? "varchar(255)"]));
-        return columns.map((c) => {
+        const udtPairs = udtKeys.map((k) => {
+            const [s, n] = k.split(".", 2);
+            return [s, n];
+        });
+        const enumDefs = await Promise.all(udtPairs.map(([schema, name]) => getPgEnumDefinition(schema, name)));
+        const enumMap = new Map(udtKeys.map((k, i) => [k, enumDefs[i] ?? "varchar(255)"]));
+        const cols = columns.map((c) => {
             let type;
-            if (c.data_type === "USER-DEFINED" && c.udt_name != null) {
-                type = enumMap.get(c.udt_name) ?? "character varying(255)";
+            if (c.data_type === "USER-DEFINED" &&
+                c.udt_schema != null &&
+                c.udt_name != null) {
+                const enumKey = `${c.udt_schema}.${c.udt_name}`;
+                type = enumMap.get(enumKey) ?? "character varying(255)";
             }
             else {
                 type = c.data_type;
@@ -1839,9 +1914,18 @@ const getTableMeta = (0, memoize_1.default)(async function getTableMeta(table) {
                 Type: type,
                 Null: c.is_nullable === "YES" ? "YES" : "NO",
                 Key: keyMap.get(c.Field) ?? "",
-                Default: c.Default ?? ""
+                // Preserve `null` when there is no default so that
+                // required-field detection (via `hasDefault`) works
+                // consistently with the MySQL `DESCRIBE` output.
+                Default: c.Default,
+                ...(c.data_type === "USER-DEFINED" &&
+                    c.udt_schema != null &&
+                    c.udt_name != null
+                    ? { PgType: c.udt_name }
+                    : {})
             };
         });
+        return _.sortBy((c) => c.Field, cols);
     }
     throw new Error("Unsupported dialect: " + dialect);
 }, (table) => getCtx().runId + ":" + table);
@@ -1859,7 +1943,21 @@ async function getShowCreateTable(table) {
         ]);
         const refByFk = new Map(relations.map((r) => [r.foreignKey, r]));
         const columnDefs = tableMeta.map((c) => {
-            let def = `"${c.Field.replace(/"/g, '""')}" ${c.Type} ${c.Null === "YES" ? "NULL" : "NOT NULL"}`;
+            const isSerialPk = c.Key === "PRI" &&
+                c.Default != null &&
+                c.Default !== "" &&
+                /nextval\s*\(/i.test(c.Default);
+            if (isSerialPk) {
+                const baseType = (c.PgType ?? c.Type).toLowerCase();
+                const serialType = baseType === "bigint" || baseType === "int8"
+                    ? "BIGSERIAL"
+                    : baseType === "smallint" || baseType === "int2"
+                        ? "SMALLSERIAL"
+                        : "SERIAL";
+                return `"${c.Field.replace(/"/g, '""')}" ${serialType} PRIMARY KEY`;
+            }
+            const pgType = c.PgType ?? c.Type;
+            let def = `"${c.Field.replace(/"/g, '""')}" ${pgType} ${c.Null === "YES" ? "NULL" : "NOT NULL"}`;
             if (c.Default != null && c.Default !== "") {
                 def += ` DEFAULT ${c.Default}`;
             }
@@ -1873,7 +1971,7 @@ async function getShowCreateTable(table) {
             }
             return def;
         });
-        return `CREATE TABLE "${table.replace(/"/g, '""')}" (\n  ${columnDefs.join(",\n  ")}\n)`;
+        return `CREATE TABLE "${table.replace(/"/g, '""')}" (\n  ${columnDefs.join(",\n  ")}\n);`;
     }
     return Promise.resolve(null);
 }
@@ -2043,18 +2141,18 @@ function getPropertyFormat(sqlType) {
     }
     return undefined;
 }
-async function getTableNames() {
+const getTableNames = (0, memoize_1.default)(async function getTableNames() {
     const { dialect, query } = getCtx();
     if (dialect === "mysql") {
         return query("SHOW TABLES").then((xs) => xs.flatMap((x) => Object.values(x)).sort());
     }
     if (dialect === "postgresql") {
         return query(`SELECT table_name FROM information_schema.tables
-       WHERE table_schema = 'public' AND table_type = 'BASE TABLE'
-       ORDER BY table_name`).then((rows) => rows.map((r) => r.table_name));
+         WHERE table_schema = 'public' AND table_type = 'BASE TABLE'
+         ORDER BY table_name`).then((rows) => rows.map((r) => r.table_name));
     }
     throw new Error("Unsupported dialect: " + dialect);
-}
+}, () => getCtx().runId);
 function getMysql2sqliteSrc() {
     return `#!/usr/bin/awk -f
 

package/dist/generation/pg2sqliteSchema.d.ts

@@ -0,0 +1,6 @@
+import { Pool } from "pg";
+/**
+ * Reflects the PostgreSQL schema from the given connection and returns
+ * SQLite-compatible CREATE TABLE statements as a string.
+ */
+export declare function convertPgSchemaToSqlite(pool: Pool): Promise<string>;

package/dist/generation/pg2sqliteSchema.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertPgSchemaToSqlite = convertPgSchemaToSqlite;
+/**
+ * Reflects the PostgreSQL schema from the given connection and returns
+ * SQLite-compatible CREATE TABLE statements as a string.
+ */
+async function convertPgSchemaToSqlite(pool) {
+    const columnsResult = await pool.query(`
+    SELECT table_schema, table_name, column_name, ordinal_position,
+           data_type, character_maximum_length, is_nullable, column_default
+    FROM information_schema.columns
+    WHERE table_schema NOT IN ('pg_catalog', 'information_schema')
+    ORDER BY table_schema, table_name, ordinal_position
+  `);
+    const pkResult = await pool.query(`
+    SELECT tc.table_schema, tc.table_name, kcu.column_name
+    FROM information_schema.table_constraints tc
+    JOIN information_schema.key_column_usage kcu
+      ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema
+    WHERE tc.constraint_type = 'PRIMARY KEY'
+  `);
+    const primaryKeys = new Set(pkResult.rows.map((r) => `${r.table_schema}.${r.table_name}.${r.column_name}`));
+    const byTable = {};
+    for (const c of columnsResult.rows) {
+        const key = `${c.table_schema}.${c.table_name}`;
+        if (!byTable[key])
+            byTable[key] = [];
+        byTable[key].push(c);
+    }
+    const statements = [];
+    for (const [key, cols] of Object.entries(byTable)) {
+        const tableName = key.split(".").slice(-1)[0];
+        const parts = cols.map((c) => {
+            const sqliteType = toSqliteType(c.data_type);
+            const pk = primaryKeys.has(`${c.table_schema}.${c.table_name}.${c.column_name}`);
+            const notNull = c.is_nullable === "NO" && !(c.column_default?.includes("nextval") ?? false);
+            const defaultVal = pgDefaultToSqlite(c.column_default);
+            const pkClause = pk ? " PRIMARY KEY" : "";
+            const nullClause = notNull && !pk ? " NOT NULL" : "";
+            const defaultClause = defaultVal != null ? ` DEFAULT ${defaultVal}` : "";
+            return `  "${c.column_name}" ${sqliteType}${pkClause}${nullClause}${defaultClause}`;
+        });
+        statements.push(`CREATE TABLE "${tableName}" (\n${parts.join(",\n")}\n);`);
+    }
+    return statements.join("\n\n") + "\n";
+}
+const PG_TO_SQLITE_TYPE = {
+    smallint: "INTEGER",
+    integer: "INTEGER",
+    bigint: "INTEGER",
+    serial: "INTEGER",
+    bigserial: "INTEGER",
+    smallserial: "INTEGER",
+    real: "REAL",
+    "double precision": "REAL",
+    numeric: "REAL",
+    decimal: "REAL",
+    boolean: "INTEGER",
+    character: "TEXT",
+    "character varying": "TEXT",
+    varchar: "TEXT",
+    char: "TEXT",
+    text: "TEXT",
+    timestamp: "TEXT",
+    "timestamp with time zone": "TEXT",
+    "timestamp without time zone": "TEXT",
+    date: "TEXT",
+    time: "TEXT",
+    json: "TEXT",
+    jsonb: "TEXT",
+    uuid: "TEXT",
+    bytea: "BLOB"
+};
+function toSqliteType(pgType) {
+    const base = (pgType ?? "")
+        .toLowerCase()
+        .replace(/^(.*?)(\s+with.*|\s+without.*)$/, "$1")
+        .trim();
+    return PG_TO_SQLITE_TYPE[base] ?? "TEXT";
+}
+/**
+ * Converts a PostgreSQL column_default expression to a SQLite DEFAULT clause
+ * value (without the "DEFAULT" keyword). Returns null if we should not emit a default.
+ */
+function pgDefaultToSqlite(columnDefault) {
+    if (columnDefault == null || columnDefault.trim() === "")
+        return null;
+    const raw = columnDefault.trim();
+    // Skip sequence-based defaults (serial/identity); SQLite uses INTEGER PRIMARY KEY
+    if (raw.toLowerCase().includes("nextval"))
+        return null;
+    // Timestamp / time
+    if (/^(now\s*\(\s*\)|current_timestamp)$/i.test(raw))
+        return "CURRENT_TIMESTAMP";
+    if (/^current_date$/i.test(raw))
+        return "CURRENT_DATE";
+    if (/^current_time$/i.test(raw))
+        return "CURRENT_TIME";
+    // Booleans
+    if (/^\s*true\s*$/i.test(raw))
+        return "1";
+    if (/^\s*false\s*$/i.test(raw))
+        return "0";
+    // Numeric literal (optionally with ::type)
+    const numericMatch = raw.match(/^(-?\d+(?:\.\d+)?)\s*(?:::\s*\w+(?:\s+\w+)*)?\s*$/);
+    if (numericMatch)
+        return numericMatch[1];
+    // String literal: '...' with optional ::type
+    const stringMatch = raw.match(/^'(.*)'\s*(?:::\s*\w+(?:\s+\w+)*)?\s*$/s);
+    if (stringMatch) {
+        const inner = stringMatch[1].replace(/'/g, "''");
+        return `'${inner}'`;
+    }
+    // Unknown expression: strip ::type and emit in parens if it looks safe
+    const withoutCast = raw.replace(/\s*::\s*[\w\s]+$/, "").trim();
+    if (withoutCast && /^[\w().\s+-]+$/i.test(withoutCast)) {
+        return `(${withoutCast})`;
+    }
+    return null;
+}

package/dist/runtime/lib/shared.js

@@ -70,7 +70,9 @@ async function resolve(input, dbCall, formatQuery, beginTransaction, dialect, mi
             const shouldRunOnHandler = typeof onHandler === "function" &&
                 asyncLocalStorage != null &&
                 asyncLocalStorage?.getStore()?.isInOnHandler !== true;
-            const beforeValue = shouldRunOnHandler && input.passBeforeValueToAfterCallback
+            const beforeValue = shouldRunOnHandler &&
+                input.passBeforeValueToAfterCallback &&
+                input.action !== "create"
                 ? await _resolve({
                     ...paramsChanged,
                     action: paramsChanged.action === "updateMany" ||
@@ -103,7 +105,9 @@ async function resolve(input, dbCall, formatQuery, beginTransaction, dialect, mi
     const shouldRunOnHandler = typeof onHandler === "function" &&
         asyncLocalStorage != null &&
         asyncLocalStorage?.getStore()?.isInOnHandler !== true;
-    const beforeValue = shouldRunOnHandler && input.passBeforeValueToAfterCallback
+    const beforeValue = shouldRunOnHandler &&
+        input.passBeforeValueToAfterCallback &&
+        input.action !== "create"
         ? await _resolve({
             ...input,
             action: input.action === "updateMany" || input.action === "deleteMany"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@technicity/data-service-generator",
-  "version": "0.23.0-next.1",
+  "version": "0.23.0-next.11",
   "main": "./dist/index.js",
   "files": [
     "dist"
@@ -27,6 +27,8 @@
     "mysql2": "^3.10.1",
     "pg": "^8.13.1",
     "pg-format": "^1.0.4",
+    "pino": "^9.5.0",
+    "pino-pretty": "^13.1.3",
     "prettier": "^2.1.2",
     "sqlstring": "^2.3.2",
     "sqlstring-sqlite": "^0.1.1",