@lark-apaas/db-schema-sync 0.1.23 → 0.1.24-alpha.20261028024931

package/dist/bin.js

@@ -1,13 +1,19 @@
 #!/usr/bin/env node
 import { createRequire } from "node:module"; const require = createRequire(import.meta.url);
 import {
+  DATASOURCE_CONF_ENV,
+  DATASOURCE_TYPES,
   __commonJS,
   __require,
   __toESM,
-  generateSchema,
+  detectEngine,
+  fetchListTableView,
+  generateSchemaFromData,
+  normalizeApiResponse,
+  parseDatasourceConf,
   resolveEnvOptions,
   validateGeneratedSchema
-} from "./chunk-PXGXJ64L.js";
+} from "./chunk-KHVF5NNE.js";
 
 // node_modules/dotenv/package.json
 var require_package = __commonJS({
@@ -300,8 +306,8 @@ var require_main = __commonJS({
         const shortPaths = [];
         for (const filePath of optionPaths) {
           try {
-            const relative = path.relative(process.cwd(), filePath);
-            shortPaths.push(relative);
+            const relative2 = path.relative(process.cwd(), filePath);
+            shortPaths.push(relative2);
           } catch (e) {
             if (debug) {
               _debug(`Failed to load ${filePath} ${e.message}`);
@@ -406,10 +412,11 @@ var require_main = __commonJS({
 
 // src/bin.ts
 var import_dotenv = __toESM(require_main(), 1);
-import { resolve, dirname } from "path";
-import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { resolve as resolve2 } from "path";
+import { existsSync as existsSync2 } from "fs";
 
 // src/cli-args.ts
+var ENGINES = ["auto", "dataloom", "base"];
 function parseArgs(argv) {
   const args = argv.slice(2);
   const command = args[0] === "validate" ? "validate" : "generate";
@@ -424,9 +431,179 @@ function parseArgs(argv) {
     output: getArg("--output"),
     input: getArg("--input"),
     project: getArg("--project"),
-    exportCustomTypes: hasFlag("--export-custom-types")
+    exportCustomTypes: hasFlag("--export-custom-types"),
+    engine: parseEngine(getArg("--engine")),
+    type: parseType(getArg("--type"))
   };
 }
+function parseType(value) {
+  if (value === void 0) return void 0;
+  if (DATASOURCE_TYPES.includes(value)) return value;
+  throw new Error(
+    `[db-schema-sync] Invalid --type "${value}", expected one of: ${DATASOURCE_TYPES.join(", ")}`
+  );
+}
+function parseEngine(value) {
+  if (value === void 0) return "auto";
+  if (ENGINES.includes(value)) return value;
+  throw new Error(
+    `[db-schema-sync] Invalid --engine "${value}", expected one of: ${ENGINES.join(", ")}`
+  );
+}
+
+// src/sync.ts
+import { dirname, join, relative, resolve } from "path";
+import {
+  existsSync,
+  mkdirSync,
+  renameSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+var DEFAULT_OUTPUT = "server/database/schema.ts";
+var BASE_FILE_NAME = "base.ts";
+var errorMessage = (err) => err instanceof Error ? err.message : String(err);
+function writeFilesAtomic(files) {
+  const suffix = `.tmp-${process.pid}-${Date.now()}`;
+  const temps = [];
+  try {
+    for (const f of files) {
+      mkdirSync(dirname(f.path), { recursive: true });
+      temps.push(f.path + suffix);
+      writeFileSync(f.path + suffix, f.content, "utf8");
+    }
+  } catch (err) {
+    for (const t of temps) rmSync(t, { force: true });
+    throw err;
+  }
+  for (const f of files) renameSync(f.path + suffix, f.path);
+}
+function generatePgSchema(raw, engine, exportCustomTypes) {
+  const source = generateSchemaFromData(
+    // Base apps are treated as one default schema for now: pgTable, no pgSchema prefix
+    normalizeApiResponse(raw, engine, { baseSchemas: false }),
+    { exportCustomTypes }
+  );
+  if (!source.includes("pgTable") && !source.includes("pgView")) {
+    console.warn(
+      "[db-schema-sync] \u26A0 Warning: No tables or views found in database. The generated schema will be empty."
+    );
+  }
+  return source;
+}
+function resolveOutput(o) {
+  return o.args.output || o.env.DB_SCHEMA_OUTPUT || DEFAULT_OUTPUT;
+}
+async function runSync(o) {
+  let conf;
+  try {
+    conf = parseDatasourceConf(o.env[DATASOURCE_CONF_ENV]);
+  } catch (err) {
+    console.error(`[db-schema-sync] \u2717 ${errorMessage(err)}`);
+    return {
+      mode: "datasources",
+      failures: [{ name: DATASOURCE_CONF_ENV, message: errorMessage(err) }]
+    };
+  }
+  return conf ? runDatasources(conf, o) : runLegacy(o);
+}
+async function runLegacy(o) {
+  const { args } = o;
+  if (args.type === "base") {
+    console.log(
+      `[db-schema-sync] \u672A\u914D\u7F6E ${DATASOURCE_CONF_ENV}\uFF0C\u6CA1\u6709 base \u6570\u636E\u6E90\u53EF\u540C\u6B65`
+    );
+    return { mode: "legacy", failures: [] };
+  }
+  const output = resolveOutput(o);
+  const fetchSchema = o.fetchSchema ?? fetchListTableView;
+  try {
+    const options = resolveEnvOptions(o.env);
+    console.log("[db-schema-sync] Starting...");
+    console.log(
+      `[db-schema-sync] app_id=${options.appId}, dbBranch=${options.dbBranch}, exportCustomTypes=${args.exportCustomTypes}, engine=${args.engine}`
+    );
+    const raw = await fetchSchema(options);
+    const schema = generatePgSchema(raw, args.engine, args.exportCustomTypes);
+    writeFilesAtomic([{ path: resolve(o.cwd, output), content: schema }]);
+    console.log(`[db-schema-sync] \u2713 Schema written to ${output}`);
+    return { mode: "legacy", failures: [] };
+  } catch (err) {
+    console.error(`[db-schema-sync] \u2717 Failed:`, errorMessage(err));
+    return {
+      mode: "legacy",
+      failures: [{ name: "schema", message: errorMessage(err) }]
+    };
+  }
+}
+function assertEngineMatches(ds, raw) {
+  const engine = detectEngine(raw);
+  if (ds.type === "base" && engine !== "base") {
+    throw new Error(
+      `\u914D\u7F6E\u4E3A base\uFF0C\u4F46\u63A5\u53E3\u8FD4\u56DE\u7684\u4E0D\u662F Base \u5F15\u64CE\uFF08engine=${String(raw?.engine ?? "\u672A\u6807\u8BB0")}\uFF0C\u5B57\u6BB5 extraInfo \u4E5F\u4E0D\u5E26 Base \u5C5E\u6027\uFF09`
+    );
+  }
+  if (ds.type === "pg" && engine === "base") {
+    throw new Error("\u914D\u7F6E\u4E3A pg\uFF0C\u4F46\u63A5\u53E3\u8FD4\u56DE\u7684\u662F Base \u5F15\u64CE");
+  }
+}
+async function runDatasources(conf, o) {
+  const { args, cwd } = o;
+  const fetchSchema = o.fetchSchema ?? fetchListTableView;
+  const pgPath = resolve(cwd, resolveOutput(o));
+  const basePath = join(dirname(pgPath), BASE_FILE_NAME);
+  const rel = (p) => relative(cwd, p) || ".";
+  const types = args.type ? [args.type] : DATASOURCE_TYPES;
+  const failures = [];
+  let appOptions;
+  try {
+    appOptions = resolveEnvOptions(o.env);
+  } catch (err) {
+    console.error(`[db-schema-sync] \u2717 Failed:`, errorMessage(err));
+    return { mode: "datasources", failures: [{ name: "app_id", message: errorMessage(err) }] };
+  }
+  console.log("[db-schema-sync] Starting...");
+  const listed = conf.datasources.map((d) => `${d.type}:${d.id}`).join(", ") || "(none)";
+  console.log(
+    `[db-schema-sync] app_id=${appOptions.appId}, dbBranch=${appOptions.dbBranch}, datasources=${listed}, type=${args.type ?? "all"}`
+  );
+  if (args.engine !== "auto") {
+    console.warn(
+      `[db-schema-sync] \u26A0 \u5DF2\u914D\u7F6E ${DATASOURCE_CONF_ENV}\uFF0C\u5FFD\u7565 --engine\uFF08\u5F15\u64CE\u7531\u6570\u636E\u6E90 type \u51B3\u5B9A\uFF09`
+    );
+  }
+  for (const type of types) {
+    if (conf.datasources.some((d) => d.type === type)) continue;
+    const existing = type === "pg" ? pgPath : basePath;
+    console.log(
+      existsSync(existing) ? `[db-schema-sync] \u914D\u7F6E\u4E2D\u6CA1\u6709 ${type} \u6570\u636E\u6E90\uFF0C\u4FDD\u7559\u5DF2\u6709\u7684 ${rel(existing)}` : `[db-schema-sync] \u914D\u7F6E\u4E2D\u6CA1\u6709 ${type} \u6570\u636E\u6E90\uFF0C\u8DF3\u8FC7`
+    );
+  }
+  for (const ds of conf.datasources.filter((d) => types.includes(d.type))) {
+    const label = `${ds.type} \u6570\u636E\u6E90 ${ds.id}`;
+    try {
+      const raw = await fetchSchema({
+        appId: appOptions.appId,
+        timeoutMs: appOptions.timeoutMs,
+        datasourceId: ds.id,
+        ...ds.type === "pg" ? { dbBranch: appOptions.dbBranch } : {}
+      });
+      assertEngineMatches(ds, raw);
+      const [path, schema] = ds.type === "pg" ? [pgPath, generatePgSchema(raw, "dataloom", args.exportCustomTypes)] : [basePath, generatePgSchema(raw, "base", true)];
+      writeFilesAtomic([{ path, content: schema }]);
+      console.log(`[db-schema-sync] \u2713 ${label} \u2192 ${rel(path)}`);
+    } catch (err) {
+      failures.push({ name: label, message: errorMessage(err) });
+      console.error(`[db-schema-sync] \u2717 ${label} \u540C\u6B65\u5931\u8D25\uFF1A${errorMessage(err)}`);
+    }
+  }
+  if (failures.length > 0) {
+    console.error(
+      `[db-schema-sync] \u2717 ${failures.length} \u4E2A\u6570\u636E\u6E90\u540C\u6B65\u5931\u8D25\uFF0C\u5176\u6587\u4EF6\u4FDD\u6301\u539F\u6837\uFF1A${failures.map((f) => f.name).join("\u3001")}`
+    );
+  }
+  return { mode: "datasources", failures };
+}
 
 // src/bin.ts
 function getValidateExitCode(result) {
@@ -436,59 +613,44 @@ function getValidateExitCode(result) {
   return 1;
 }
 async function main() {
-  const cliArgs = parseArgs(process.argv);
+  let cliArgs;
+  try {
+    cliArgs = parseArgs(process.argv);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
   if (cliArgs.command === "validate") {
     if (!cliArgs.input) {
-      const output3 = {
+      const output2 = {
         ok: false,
         status: "inconclusive",
         errorType: "validation_runner_failed",
         durationMs: 0,
         message: "--input is required for validate command"
       };
-      console.log(JSON.stringify(output3));
+      console.log(JSON.stringify(output2));
       process.exit(1);
     }
-    const output2 = validateGeneratedSchema({
+    const output = validateGeneratedSchema({
       input: cliArgs.input,
       project: cliArgs.project
     });
-    console.log(JSON.stringify(output2));
-    process.exit(getValidateExitCode(output2));
+    console.log(JSON.stringify(output));
+    process.exit(getValidateExitCode(output));
   }
   for (const name of [".env.local", ".env"]) {
-    const envPath = resolve(process.cwd(), name);
-    if (existsSync(envPath)) {
+    const envPath = resolve2(process.cwd(), name);
+    if (existsSync2(envPath)) {
       (0, import_dotenv.config)({ path: envPath });
       console.log(`[db-schema-sync] \u2713 Loaded ${name}`);
     }
   }
-  const output = cliArgs.output || process.env.DB_SCHEMA_OUTPUT || "server/database/schema.ts";
-  try {
-    const options = resolveEnvOptions();
-    console.log("[db-schema-sync] Starting...");
-    console.log(
-      `[db-schema-sync] app_id=${options.appId}, dbBranch=${options.dbBranch}, exportCustomTypes=${cliArgs.exportCustomTypes}`
-    );
-    const schema = await generateSchema({
-      ...options,
-      exportCustomTypes: cliArgs.exportCustomTypes
-    });
-    if (!schema.includes("pgTable") && !schema.includes("pgView")) {
-      console.warn(
-        "[db-schema-sync] \u26A0 Warning: No tables or views found in database. The generated schema will be empty."
-      );
-    }
-    const outputPath = resolve(process.cwd(), output);
-    mkdirSync(dirname(outputPath), { recursive: true });
-    writeFileSync(outputPath, schema, "utf8");
-    console.log(`[db-schema-sync] \u2713 Schema written to ${output}`);
-  } catch (err) {
-    console.error(
-      `[db-schema-sync] \u2717 Failed:`,
-      err instanceof Error ? err.message : String(err)
-    );
-    process.exit(1);
-  }
+  const { failures } = await runSync({
+    cwd: process.cwd(),
+    env: process.env,
+    args: cliArgs
+  });
+  if (failures.length > 0) process.exit(1);
 }
 main();