@lark-apaas/db-schema-sync 0.1.18 → 0.1.19-alpha.20260904074828

package/dist/bin.js

@@ -5,8 +5,9 @@ import {
   __require,
   __toESM,
   generateSchema,
-  resolveEnvOptions
-} from "./chunk-7O4DEVTQ.js";
+  resolveEnvOptions,
+  validateGeneratedSchema
+} from "./chunk-UWBHRXTA.js";
 
 // node_modules/dotenv/package.json
 var require_package = __commonJS({
@@ -411,19 +412,50 @@ import { writeFileSync, mkdirSync, existsSync } from "fs";
 // src/cli-args.ts
 function parseArgs(argv) {
   const args = argv.slice(2);
+  const command = args[0] === "validate" ? "validate" : "generate";
+  const optionArgs = command === "validate" ? args.slice(1) : args;
   const getArg = (name) => {
-    const idx = args.indexOf(name);
-    return idx !== -1 && args[idx + 1] ? args[idx + 1] : void 0;
+    const idx = optionArgs.indexOf(name);
+    return idx !== -1 && optionArgs[idx + 1] ? optionArgs[idx + 1] : void 0;
   };
-  const hasFlag = (name) => args.includes(name);
+  const hasFlag = (name) => optionArgs.includes(name);
   return {
+    command,
     output: getArg("--output"),
+    input: getArg("--input"),
+    project: getArg("--project"),
     exportCustomTypes: hasFlag("--export-custom-types")
   };
 }
 
 // src/bin.ts
+function getValidateExitCode(result) {
+  if (result.ok) return 0;
+  if (result.status === "invalid_artifact") return 2;
+  if (result.status === "inconclusive") return 3;
+  return 1;
+}
 async function main() {
+  const cliArgs = parseArgs(process.argv);
+  if (cliArgs.command === "validate") {
+    if (!cliArgs.input) {
+      const output3 = {
+        ok: false,
+        status: "inconclusive",
+        errorType: "validation_runner_failed",
+        durationMs: 0,
+        message: "--input is required for validate command"
+      };
+      console.log(JSON.stringify(output3));
+      process.exit(1);
+    }
+    const output2 = validateGeneratedSchema({
+      input: cliArgs.input,
+      project: cliArgs.project
+    });
+    console.log(JSON.stringify(output2));
+    process.exit(getValidateExitCode(output2));
+  }
   for (const name of [".env.local", ".env"]) {
     const envPath = resolve(process.cwd(), name);
     if (existsSync(envPath)) {
@@ -431,25 +463,31 @@ async function main() {
       console.log(`[db-schema-sync] \u2713 Loaded ${name}`);
     }
   }
-  const cliArgs = parseArgs(process.argv);
   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}`);
+    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.");
+      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));
+    console.error(
+      `[db-schema-sync] \u2717 Failed:`,
+      err instanceof Error ? err.message : String(err)
+    );
     process.exit(1);
   }
 }

package/dist/{chunk-7O4DEVTQ.js → chunk-UWBHRXTA.js}

@@ -268,11 +268,11 @@ var require_dist = __commonJS({
           if (cached && cached.expiresAtMs - now > this.refreshBeforeMs) {
             return { token: cached.token, accessKey: cached.accessKey };
           }
-          const result = this.readAndParse(filePath);
-          if (result) {
-            this.cache.set(filePath, result);
-            if (result.expiresAtMs > now) {
-              return { token: result.token, accessKey: result.accessKey };
+          const result2 = this.readAndParse(filePath);
+          if (result2) {
+            this.cache.set(filePath, result2);
+            if (result2.expiresAtMs > now) {
+              return { token: result2.token, accessKey: result2.accessKey };
             }
           }
           if (cached && cached.expiresAtMs > now) {
@@ -1157,15 +1157,15 @@ function toAsciiName(name) {
     return name;
   }
   try {
-    const result = [];
+    const result2 = [];
     for (const char of name) {
       if (/[^\x00-\x7F]/.test(char) && import_tiny_pinyin.default.isSupported()) {
-        result.push(import_tiny_pinyin.default.convertToPinyin(char, "", true));
+        result2.push(import_tiny_pinyin.default.convertToPinyin(char, "", true));
       } else {
-        result.push(char);
+        result2.push(char);
       }
     }
-    return result.join("_") || name;
+    return result2.join("_") || name;
   } catch {
     return name;
   }
@@ -1847,13 +1847,13 @@ var defaultModifiers = [
   }
 ];
 function applyModifiers(field, modifiers) {
-  let result = "";
+  let result2 = "";
   for (const mod of modifiers) {
     if (mod.match(field)) {
-      result += mod.modify(field);
+      result2 += mod.modify(field);
     }
   }
-  return result;
+  return result2;
 }
 
 // src/generator/structures/enum.ts
@@ -1863,19 +1863,17 @@ function generateEnumCode(schema) {
 }
 
 // src/generator/structures/index-gen.ts
-function generateIndexCode(idx, tableIdentifier, knownColumnProperties) {
+function generateIndexCode(idx, tableIdentifier) {
   const fn = idx.indexType === "unique" ? "uniqueIndex" : "index";
-  const propertyRefs = idx.indexColumns.map((col) => sanitizePropertyName(col));
-  const columns = propertyRefs.map((prop) => `table.${prop}`).join(", ");
+  const columns = idx.indexColumns.map((col) => `table.${sanitizePropertyName(col)}`).join(", ");
   const escapedName = escapeDoubleQuote(idx.indexName);
-  const allColumnsKnown = knownColumnProperties === void 0 ? true : propertyRefs.every((prop) => knownColumnProperties.has(prop));
-  if (!columns || !allColumnsKnown) {
-    return `// Complex index: ${idx.indexDef || idx.indexName}`;
-  }
   const creationType = idx.indexCreationType || "btree";
-  if (creationType !== "btree") {
+  if (creationType !== "btree" && columns) {
     return `${fn}("${escapedName}").using("${creationType}", ${columns})`;
   }
+  if (!columns) {
+    return `// Complex index: ${idx.indexDef || idx.indexName}`;
+  }
   return `${fn}("${escapedName}").on(${columns})`;
 }
 
@@ -1901,18 +1899,16 @@ function generateForeignKeyCode(rel, tableIdentifier, tableIdentifierMap) {
 
 // src/generator/structures/table.ts
 function generateTableCode(table, schemaData, registry, modifiers, tableIdentifierMap) {
-  const knownColumnProperties = /* @__PURE__ */ new Set();
   const fieldLines = table.fields.map((field) => {
     const mapper = registry.resolve(field);
     const typeExpr = mapper.generate(field);
     const mods = applyModifiers(field, modifiers);
     const propName = sanitizePropertyName(field.fieldName);
-    knownColumnProperties.add(propName);
     return `  ${propName}: ${typeExpr}${mods},`;
   });
   const thirdArgParts = [];
   for (const idx of table.indexes) {
-    thirdArgParts.push(generateIndexCode(idx, table.identifier, knownColumnProperties));
+    thirdArgParts.push(generateIndexCode(idx, table.identifier));
   }
   for (const rel of table.relationships) {
     thirdArgParts.push(generateForeignKeyCode(rel, table.identifier, tableIdentifierMap));
@@ -2032,10 +2028,10 @@ function runEnhancers(source, enhancers, context) {
   let current = source;
   const allStats = {};
   for (const enhancer of enhancers) {
-    const result = enhancer.enhance(current, context);
-    current = result.source;
-    if (result.stats) {
-      allStats[enhancer.name] = result.stats;
+    const result2 = enhancer.enhance(current, context);
+    current = result2.source;
+    if (result2.stats) {
+      allStats[enhancer.name] = result2.stats;
     }
   }
   return { source: current, allStats };
@@ -2350,7 +2346,7 @@ var jsonbCommentsEnhancer = {
       return { source, stats: { commentsAdded: 0 } };
     }
     const lines = source.split("\n");
-    const result = [];
+    const result2 = [];
     let commentsAdded = 0;
     let currentTableName = null;
     for (let i = 0; i < lines.length; i++) {
@@ -2374,7 +2370,7 @@ var jsonbCommentsEnhancer = {
           const parsed = parseColumnComment(comment);
           const indentMatch = line.match(/^\s*/);
           const indent = indentMatch ? indentMatch[0] : "";
-          const prevLine = result[result.length - 1]?.trim() ?? "";
+          const prevLine = result2[result2.length - 1]?.trim() ?? "";
           if (!prevLine.startsWith("/**") && !prevLine.startsWith("*") && !prevLine.startsWith("//")) {
             const commentLines = [];
             commentLines.push(`${indent}/**`);
@@ -2390,7 +2386,7 @@ var jsonbCommentsEnhancer = {
               commentLines.push(`${indent} * @type ${safeType}`);
             }
             commentLines.push(`${indent} */`);
-            result.push(...commentLines);
+            result2.push(...commentLines);
             commentsAdded++;
           }
         }
@@ -2398,10 +2394,10 @@ var jsonbCommentsEnhancer = {
       if (line.match(/^\}\);?\s*$/) || line.match(/^}\s*,\s*\{/)) {
         currentTableName = null;
       }
-      result.push(line);
+      result2.push(line);
     }
     return {
-      source: result.join("\n"),
+      source: result2.join("\n"),
       stats: { commentsAdded }
     };
   }
@@ -2464,7 +2460,7 @@ var syncedCommentsEnhancer = {
       return { source };
     }
     const lines = source.split("\n");
-    const result = [];
+    const result2 = [];
     let commentsAdded = 0;
     let currentSyncedFields = null;
     let insideTableBody = false;
@@ -2479,11 +2475,11 @@ var syncedCommentsEnhancer = {
           currentSyncedFields = syncedFields;
           insideTableBody = true;
           braceDepth = 0;
-          const prevLine = result[result.length - 1]?.trim() ?? "";
+          const prevLine = result2[result2.length - 1]?.trim() ?? "";
           if (!prevLine.includes("Synced table")) {
             const indentMatch = line.match(/^\s*/);
             const indent = indentMatch ? indentMatch[0] : "";
-            result.push(`${indent}// ${TABLE_COMMENT}`);
+            result2.push(`${indent}// ${TABLE_COMMENT}`);
             commentsAdded++;
           }
         }
@@ -2500,20 +2496,20 @@ var syncedCommentsEnhancer = {
         if (currentSyncedFields && braceDepth >= 1 && !tableMatch) {
           const columnName = extractColumnName(line);
           if (columnName && currentSyncedFields.has(columnName)) {
-            const prevLine = result[result.length - 1]?.trim() ?? "";
+            const prevLine = result2[result2.length - 1]?.trim() ?? "";
             if (!prevLine.includes("Synced field")) {
               const indentMatch = line.match(/^\s*/);
               const indent = indentMatch ? indentMatch[0] : "";
-              result.push(`${indent}// ${FIELD_COMMENT}`);
+              result2.push(`${indent}// ${FIELD_COMMENT}`);
               commentsAdded++;
             }
           }
         }
       }
-      result.push(line);
+      result2.push(line);
     }
     return {
-      source: result.join("\n"),
+      source: result2.join("\n"),
       stats: { commentsAdded }
     };
   }
@@ -2584,6 +2580,260 @@ var defaultEnhancers = [
   formatEnhancer
 ];
 
+// src/validator.ts
+import { spawnSync } from "child_process";
+import {
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { tmpdir } from "os";
+import { dirname, delimiter, join, resolve } from "path";
+function truncateMessage(message) {
+  return message.length > 500 ? `${message.slice(0, 500)}...` : message;
+}
+function result(params, startTime) {
+  return {
+    ...params,
+    durationMs: Date.now() - startTime
+  };
+}
+function findConfigFile(startDir, fileName) {
+  let current = startDir;
+  while (true) {
+    const candidate = join(current, fileName);
+    if (existsSync(candidate)) return candidate;
+    const parent = dirname(current);
+    if (parent === current) return void 0;
+    current = parent;
+  }
+}
+function findTsc(cwd) {
+  const localTsc = join(
+    cwd,
+    "node_modules",
+    ".bin",
+    process.platform === "win32" ? "tsc.cmd" : "tsc"
+  );
+  if (existsSync(localTsc)) return localTsc;
+  const pathEnv = process.env.PATH ?? "";
+  for (const dir of pathEnv.split(delimiter)) {
+    if (!dir) continue;
+    const candidate = join(
+      dir,
+      process.platform === "win32" ? "tsc.cmd" : "tsc"
+    );
+    if (existsSync(candidate)) return candidate;
+  }
+  return void 0;
+}
+function resolveProjectPath(params) {
+  if (params.project) return resolve(params.cwd, params.project);
+  return findConfigFile(dirname(params.inputPath), "tsconfig.node.json") ?? findConfigFile(dirname(params.inputPath), "tsconfig.json");
+}
+function createValidationTsconfig(params) {
+  const dir = mkdtempSync(join(tmpdir(), "db-schema-sync-validate-"));
+  const configPath = join(dir, "tsconfig.schema-validation.json");
+  const compilerOptions = {
+    noEmit: true,
+    skipLibCheck: true,
+    types: [],
+    rootDir: dirname(params.inputPath)
+  };
+  const config = params.projectPath ? {
+    extends: params.projectPath,
+    compilerOptions,
+    files: [params.inputPath],
+    include: [],
+    exclude: []
+  } : {
+    compilerOptions: {
+      target: "ES2022",
+      module: "NodeNext",
+      moduleResolution: "NodeNext",
+      esModuleInterop: true,
+      strict: false,
+      ...compilerOptions
+    },
+    files: [params.inputPath],
+    include: [],
+    exclude: []
+  };
+  writeFileSync(configPath, JSON.stringify(config), "utf8");
+  return { dir, path: configPath };
+}
+function runTsc(tscPath, cwd, args) {
+  return spawnSync(tscPath, args, {
+    cwd,
+    encoding: "utf8",
+    maxBuffer: 1024 * 1024
+  });
+}
+function getTscOutput(output) {
+  return truncateMessage(
+    [output.stdout, output.stderr].filter(Boolean).join("\n").trim()
+  );
+}
+function getFirstDiagnosticCode(output) {
+  const match = output.match(/error TS(\d+):/);
+  return match ? Number(match[1]) : void 0;
+}
+function isSyntaxDiagnostic(output) {
+  const code = getFirstDiagnosticCode(output);
+  return typeof code === "number" && code >= 1e3 && code < 2e3;
+}
+function isConfigDiagnostic(output) {
+  const code = getFirstDiagnosticCode(output);
+  return typeof code === "number" && code >= 5e3 && code < 6e3 || /tsconfig(?:\.[\w-]+)?\.json/i.test(output);
+}
+function isNoCheckUnsupported(output) {
+  return /Unknown compiler option ['"]?--?noCheck['"]?/i.test(output);
+}
+function classifyFailedTscOutput(output) {
+  if (isConfigDiagnostic(output)) {
+    return {
+      status: "inconclusive",
+      errorType: "validation_runner_failed",
+      message: output || "TypeScript validation runner failed"
+    };
+  }
+  if (isSyntaxDiagnostic(output)) {
+    return {
+      status: "invalid_artifact",
+      errorType: "generated_schema_syntax_error",
+      message: output || "TypeScript syntax validation failed"
+    };
+  }
+  if (getFirstDiagnosticCode(output) === void 0) {
+    return {
+      status: "inconclusive",
+      errorType: "validation_runner_failed",
+      message: output || "TypeScript validation runner failed"
+    };
+  }
+  return {
+    status: "invalid_artifact",
+    errorType: "generated_schema_type_error",
+    message: output || "TypeScript validation failed"
+  };
+}
+function validateGeneratedSchema(options) {
+  const startTime = Date.now();
+  const cwd = options.cwd ?? process.cwd();
+  const inputPath = resolve(cwd, options.input);
+  try {
+    if (!existsSync(inputPath)) {
+      return result(
+        {
+          ok: false,
+          status: "invalid_artifact",
+          errorType: "generated_schema_missing",
+          message: `Generated schema file not found: ${options.input}`
+        },
+        startTime
+      );
+    }
+    if (!readFileSync(inputPath, "utf8").trim()) {
+      return result(
+        {
+          ok: false,
+          status: "invalid_artifact",
+          errorType: "generated_schema_missing",
+          message: `Generated schema file is empty: ${options.input}`
+        },
+        startTime
+      );
+    }
+    const tscPath = findTsc(cwd);
+    if (!tscPath) {
+      return result(
+        {
+          ok: false,
+          status: "inconclusive",
+          errorType: "validation_runner_failed",
+          message: "TypeScript compiler not found in sandbox. Please install project dependencies so node_modules/.bin/tsc is available."
+        },
+        startTime
+      );
+    }
+    const projectPath = resolveProjectPath({
+      cwd,
+      inputPath,
+      project: options.project
+    });
+    const tempConfig = createValidationTsconfig({ inputPath, projectPath });
+    try {
+      const syntaxOnly = runTsc(tscPath, cwd, [
+        "--noEmit",
+        "--pretty",
+        "false",
+        "--project",
+        tempConfig.path,
+        "--noCheck"
+      ]);
+      const syntaxOutput = getTscOutput(syntaxOnly);
+      if (syntaxOnly.error) {
+        throw syntaxOnly.error;
+      }
+      if (syntaxOnly.status !== 0 && !isNoCheckUnsupported(syntaxOutput)) {
+        const failure = classifyFailedTscOutput(syntaxOutput);
+        return result(
+          {
+            ok: false,
+            ...failure
+          },
+          startTime
+        );
+      }
+      const fullCheck = runTsc(tscPath, cwd, [
+        "--noEmit",
+        "--pretty",
+        "false",
+        "--project",
+        tempConfig.path
+      ]);
+      const fullOutput = getTscOutput(fullCheck);
+      if (fullCheck.error) {
+        throw fullCheck.error;
+      }
+      if (fullCheck.status !== 0) {
+        const failure = classifyFailedTscOutput(fullOutput);
+        return result(
+          {
+            ok: false,
+            ...failure
+          },
+          startTime
+        );
+      }
+    } finally {
+      rmSync(tempConfig.dir, { recursive: true, force: true });
+    }
+    return result(
+      {
+        ok: true,
+        status: "success",
+        errorType: "none"
+      },
+      startTime
+    );
+  } catch (error) {
+    return result(
+      {
+        ok: false,
+        status: "inconclusive",
+        errorType: "validation_runner_failed",
+        message: truncateMessage(
+          error instanceof Error ? error.message : String(error)
+        )
+      },
+      startTime
+    );
+  }
+}
+
 // src/index.ts
 async function generateSchema(options) {
   const schemaData = await fetchSchemaData(options);
@@ -2607,6 +2857,7 @@ export {
   resolveEnvOptions,
   normalizeApiResponse,
   generateSchemaCode,
+  validateGeneratedSchema,
   generateSchema,
   generateSchemaFromData
 };

package/dist/index.d.ts

@@ -170,6 +170,22 @@ declare function normalizeApiResponse(response: ApiTableViewResponse | null | un
 
 declare function generateSchemaCode(data: SchemaData): string;
 
+type SchemaValidationStatus = 'success' | 'invalid_artifact' | 'inconclusive';
+type SchemaValidationErrorType = 'none' | 'generated_schema_missing' | 'generated_schema_syntax_error' | 'generated_schema_type_error' | 'validation_runner_failed';
+interface SchemaValidationOutput {
+    ok: boolean;
+    status: SchemaValidationStatus;
+    errorType: SchemaValidationErrorType;
+    durationMs: number;
+    message?: string;
+}
+interface ValidateGeneratedSchemaOptions {
+    input: string;
+    project?: string;
+    cwd?: string;
+}
+declare function validateGeneratedSchema(options: ValidateGeneratedSchemaOptions): SchemaValidationOutput;
+
 interface GenerateSchemaOptions extends FetchOptions {
     /** Skip specific enhancers by name */
     skipEnhancers?: string[];
@@ -189,4 +205,4 @@ declare function generateSchemaFromData(schemaData: SchemaData, options?: {
     exportCustomTypes?: boolean;
 }): string;
 
-export { type EnumSchema, type FetchOptions, type FieldSchema, type GenerateSchemaOptions, type SchemaData, type TableSchema, type ViewSchema, generateSchema, generateSchemaCode, generateSchemaFromData, normalizeApiResponse, resolveEnvOptions };
+export { type EnumSchema, type FetchOptions, type FieldSchema, type GenerateSchemaOptions, type SchemaData, type SchemaValidationErrorType, type SchemaValidationOutput, type SchemaValidationStatus, type TableSchema, type ViewSchema, generateSchema, generateSchemaCode, generateSchemaFromData, normalizeApiResponse, resolveEnvOptions, validateGeneratedSchema };

package/dist/index.js

@@ -4,12 +4,14 @@ import {
   generateSchemaCode,
   generateSchemaFromData,
   normalizeApiResponse,
-  resolveEnvOptions
-} from "./chunk-7O4DEVTQ.js";
+  resolveEnvOptions,
+  validateGeneratedSchema
+} from "./chunk-UWBHRXTA.js";
 export {
   generateSchema,
   generateSchemaCode,
   generateSchemaFromData,
   normalizeApiResponse,
-  resolveEnvOptions
+  resolveEnvOptions,
+  validateGeneratedSchema
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-apaas/db-schema-sync",
-  "version": "0.1.18",
+  "version": "0.1.19-alpha.20260904074828",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",