@technicity/data-service-generator 0.23.0-next.2 → 0.23.0-next.4

package/dist/generation/generate.js

@@ -44,6 +44,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();
@@ -68,7 +69,8 @@ async function generate(input) {
     const ctx = {
         runId: node_crypto_1.default.randomUUID(),
         dialect: input.dialect,
-        query: undefined
+        query: undefined,
+        pool: undefined
     };
     return ctxStorage.run(ctx, async () => {
         init(input);
@@ -174,38 +176,46 @@ 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 (getCtx().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 (getCtx().dialect === "postgresql") {
+                schemaSqlite = await (0, pg2sqliteSchema_1.convertPgSchemaToSqlite)(getCtx().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);
@@ -219,24 +229,28 @@ 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,
+            host: host ?? "localhost",
+            port: port ?? 3306,
             database
-        });
+        };
+        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
-        });
+        };
+        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,
@@ -1624,7 +1638,7 @@ 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) {
@@ -1824,7 +1838,7 @@ const getTableMeta = (0, memoize_1.default)(async function getTableMeta(table) {
         ];
         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 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)";
@@ -1841,9 +1855,13 @@ 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 ?? ""
+                Default: c.Default ?? "",
+                ...(c.data_type === "USER-DEFINED" && c.udt_name != null
+                    ? { PgType: c.udt_name }
+                    : {})
             };
         });
+        return _.sortBy((c) => c.Field, cols);
     }
     throw new Error("Unsupported dialect: " + dialect);
 }, (table) => getCtx().runId + ":" + table);
@@ -1861,7 +1879,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}`;
             }
@@ -1875,7 +1907,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);
 }

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@technicity/data-service-generator",
-  "version": "0.23.0-next.2",
+  "version": "0.23.0-next.4",
   "main": "./dist/index.js",
   "files": [
     "dist"