@lark-apaas/db-schema-sync 0.1.21 → 0.1.22-alpha.20261015232825

package/dist/bin.d.ts

@@ -1 +1,4 @@
 #!/usr/bin/env node
+declare function main(argv?: string[]): Promise<void>;
+
+export { main };

package/dist/bin.js

@@ -4,10 +4,11 @@ import {
   __commonJS,
   __require,
   __toESM,
+  checkSchemaConsumerCompatibility,
   generateSchema,
   resolveEnvOptions,
   validateGeneratedSchema
-} from "./chunk-T3RIJCQD.js";
+} from "./chunk-EVOKG4DJ.js";
 
 // node_modules/dotenv/package.json
 var require_package = __commonJS({
@@ -406,8 +407,9 @@ 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 { existsSync as existsSync2, realpathSync } from "fs";
+import { resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
 
 // src/cli-args.ts
 function parseArgs(argv) {
@@ -428,6 +430,215 @@ function parseArgs(argv) {
   };
 }
 
+// src/safe-writer.ts
+import { createHash, randomUUID } from "crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { basename, dirname, join, resolve } from "path";
+var SCHEMA_SYNC_CONTRACT = "db-schema-sync.safe-write.v1";
+var MAX_RESULT_MESSAGE_LENGTH = 500;
+function boundedMessage(message) {
+  const normalized = message.replace(/\s+/g, " ").trim();
+  return normalized.length > MAX_RESULT_MESSAGE_LENGTH ? `${normalized.slice(0, MAX_RESULT_MESSAGE_LENGTH)}...` : normalized;
+}
+function messageFrom(error) {
+  return boundedMessage(error instanceof Error ? error.message : String(error));
+}
+function sha256(bytes) {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+function readTargetSnapshot(outputPath) {
+  if (!existsSync(outputPath)) {
+    return { bytes: null, sha: null };
+  }
+  const bytes = readFileSync(outputPath);
+  return { bytes, sha: sha256(bytes) };
+}
+function makeResult(status, initial, params = {}) {
+  return {
+    contract: SCHEMA_SYNC_CONTRACT,
+    ok: params.ok ?? false,
+    status,
+    changed: params.changed ?? false,
+    targetShaBefore: initial?.sha ?? null,
+    targetShaAfter: params.targetShaAfter === void 0 ? initial?.sha ?? null : params.targetShaAfter,
+    removedExportCount: params.removedExportCount ?? 0,
+    newDiagnosticCount: params.newDiagnosticCount ?? 0,
+    diagnosticSummary: params.diagnosticSummary ?? [],
+    ...params.message ? { message: boundedMessage(params.message) } : {}
+  };
+}
+function tempPathFor(outputPath) {
+  return join(
+    dirname(outputPath),
+    `.${basename(outputPath)}.${process.pid}.${randomUUID()}.tmp.ts`
+  );
+}
+function hasGeneratedDatabaseObjects(source) {
+  return /\bexport\s+const\s+[A-Za-z_$][\w$]*\s*=\s*(?:pgTable|pgView|pgMaterializedView)\s*\(/.test(
+    source
+  );
+}
+function validationFailureMessage(validation) {
+  return `Generated schema validation failed (${validation.errorType}): ${validation.message ?? validation.status}`;
+}
+function compatibilityFailureResult(initial, compatibility) {
+  const common = {
+    removedExportCount: compatibility.removedExportCount,
+    newDiagnosticCount: compatibility.newDiagnosticCount,
+    diagnosticSummary: compatibility.diagnosticSummary,
+    message: compatibility.message ?? "Candidate schema consumer compatibility check failed"
+  };
+  return compatibility.status === "incompatible" ? makeResult("schema_consumer_incompatible", initial, common) : makeResult("schema_compatibility_unavailable", initial, common);
+}
+function writeSchemaFileSafely(options) {
+  const cwd = resolve(options.cwd ?? process.cwd());
+  const outputPath = resolve(cwd, options.outputPath);
+  let initial;
+  try {
+    initial = readTargetSnapshot(outputPath);
+  } catch (error) {
+    return makeResult("schema_target_read_failed", void 0, {
+      message: messageFrom(error)
+    });
+  }
+  try {
+    mkdirSync(dirname(outputPath), { recursive: true });
+  } catch (error) {
+    return makeResult("schema_candidate_write_failed", initial, {
+      message: messageFrom(error)
+    });
+  }
+  const tempPath = options.controls?.createTempPath?.(outputPath) ?? tempPathFor(outputPath);
+  const validate = options.validate ?? validateGeneratedSchema;
+  const checkCompatibility = options.controls?.checkCompatibility ?? checkSchemaConsumerCompatibility;
+  const rename = options.controls?.rename ?? renameSync;
+  let outcome;
+  const evaluateCandidate = () => {
+    try {
+      writeFileSync(tempPath, options.schema, "utf8");
+    } catch (error) {
+      return makeResult("schema_candidate_write_failed", initial, {
+        message: messageFrom(error)
+      });
+    }
+    let validation;
+    try {
+      validation = validate({
+        input: tempPath,
+        project: options.project,
+        cwd
+      });
+    } catch (error) {
+      return makeResult("schema_candidate_validation_unavailable", initial, {
+        message: messageFrom(error)
+      });
+    }
+    if (!validation.ok) {
+      const status = validation.status === "invalid_artifact" ? "schema_candidate_invalid" : "schema_candidate_validation_unavailable";
+      return makeResult(status, initial, {
+        message: validationFailureMessage(validation)
+      });
+    }
+    const oldSource = initial.bytes?.toString("utf8");
+    if (oldSource !== void 0 && hasGeneratedDatabaseObjects(oldSource) && !hasGeneratedDatabaseObjects(options.schema)) {
+      return makeResult("schema_zero_objects", initial, {
+        message: `Refusing to overwrite existing schema with a zero-object candidate: ${options.displayPath}`
+      });
+    }
+    if (initial.bytes?.equals(Buffer.from(options.schema, "utf8"))) {
+      try {
+        options.controls?.beforeFinalTargetRead?.();
+        const current2 = readTargetSnapshot(outputPath);
+        if (current2.sha !== initial.sha) {
+          return makeResult("schema_target_changed", initial, {
+            targetShaAfter: current2.sha,
+            message: "Schema target changed after validation; the candidate was not installed"
+          });
+        }
+        return makeResult("schema_unchanged", initial, {
+          ok: true,
+          targetShaAfter: current2.sha
+        });
+      } catch (error) {
+        return makeResult("schema_target_read_failed", initial, {
+          message: messageFrom(error)
+        });
+      }
+    }
+    let compatibility;
+    if (oldSource !== void 0) {
+      try {
+        compatibility = checkCompatibility({
+          cwd,
+          targetPath: outputPath,
+          oldSource,
+          candidateSource: options.schema,
+          project: options.project
+        });
+      } catch (error) {
+        return makeResult("schema_compatibility_unavailable", initial, {
+          message: messageFrom(error)
+        });
+      }
+      if (!compatibility.ok) {
+        return compatibilityFailureResult(initial, compatibility);
+      }
+    }
+    let current;
+    try {
+      options.controls?.beforeFinalTargetRead?.();
+      current = readTargetSnapshot(outputPath);
+    } catch (error) {
+      return makeResult("schema_target_read_failed", initial, {
+        removedExportCount: compatibility?.removedExportCount,
+        message: messageFrom(error)
+      });
+    }
+    if (current.sha !== initial.sha) {
+      return makeResult("schema_target_changed", initial, {
+        targetShaAfter: current.sha,
+        removedExportCount: compatibility?.removedExportCount,
+        message: "Schema target changed after validation; the candidate was not installed"
+      });
+    }
+    try {
+      rename(tempPath, outputPath);
+    } catch (error) {
+      return makeResult("schema_replace_failed", initial, {
+        removedExportCount: compatibility?.removedExportCount,
+        message: messageFrom(error)
+      });
+    }
+    return makeResult("schema_written", initial, {
+      ok: true,
+      changed: true,
+      targetShaAfter: sha256(Buffer.from(options.schema, "utf8")),
+      removedExportCount: compatibility?.removedExportCount
+    });
+  };
+  outcome = evaluateCandidate();
+  try {
+    if (existsSync(tempPath)) {
+      rmSync(tempPath, { force: true });
+    }
+  } catch (error) {
+    outcome = makeResult("schema_cleanup_failed", initial, {
+      removedExportCount: outcome.removedExportCount,
+      newDiagnosticCount: outcome.newDiagnosticCount,
+      diagnosticSummary: outcome.diagnosticSummary,
+      message: `Temporary candidate cleanup failed: ${messageFrom(error)}`
+    });
+  }
+  return outcome;
+}
+
 // src/bin.ts
 function getValidateExitCode(result) {
   if (result.ok) return 0;
@@ -435,8 +646,38 @@ function getValidateExitCode(result) {
   if (result.status === "inconclusive") return 3;
   return 1;
 }
-async function main() {
-  const cliArgs = parseArgs(process.argv);
+function boundedMessage2(error) {
+  const message = (error instanceof Error ? error.message : String(error)).replace(/\s+/g, " ").trim();
+  return message.length > 500 ? `${message.slice(0, 500)}...` : message;
+}
+function generationFailure(error) {
+  return {
+    contract: SCHEMA_SYNC_CONTRACT,
+    ok: false,
+    status: "schema_generation_failed",
+    changed: false,
+    targetShaBefore: null,
+    targetShaAfter: null,
+    removedExportCount: 0,
+    newDiagnosticCount: 0,
+    diagnosticSummary: [],
+    message: boundedMessage2(error)
+  };
+}
+function emitSchemaSyncResult(result) {
+  console.log(JSON.stringify(result));
+}
+function isDirectExecution() {
+  const entryPath = process.argv[1];
+  if (!entryPath) return false;
+  try {
+    return realpathSync(fileURLToPath(import.meta.url)) === realpathSync(resolve2(entryPath));
+  } catch {
+    return false;
+  }
+}
+async function main(argv = process.argv) {
+  const cliArgs = parseArgs(argv);
   if (cliArgs.command === "validate") {
     if (!cliArgs.input) {
       const output3 = {
@@ -447,18 +688,20 @@ async function main() {
         message: "--input is required for validate command"
       };
       console.log(JSON.stringify(output3));
-      process.exit(1);
+      process.exitCode = 1;
+      return;
     }
     const output2 = validateGeneratedSchema({
       input: cliArgs.input,
       project: cliArgs.project
     });
     console.log(JSON.stringify(output2));
-    process.exit(getValidateExitCode(output2));
+    process.exitCode = getValidateExitCode(output2);
+    return;
   }
   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}`);
     }
@@ -474,21 +717,45 @@ async function main() {
       ...options,
       exportCustomTypes: cliArgs.exportCustomTypes
     });
-    if (!schema.includes("pgTable") && !schema.includes("pgView")) {
+    if (!hasGeneratedDatabaseObjects(schema)) {
       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}`);
+    const result = writeSchemaFileSafely({
+      outputPath: resolve2(process.cwd(), output),
+      displayPath: output,
+      schema,
+      project: cliArgs.project,
+      cwd: process.cwd()
+    });
+    if (!result.ok) {
+      console.error(
+        `[db-schema-sync] \u2717 Failed (${result.status}): ${result.message ?? "schema was not replaced"}`
+      );
+      emitSchemaSyncResult(result);
+      process.exitCode = 1;
+      return;
+    }
+    if (result.changed) {
+      console.log(`[db-schema-sync] \u2713 Schema written to ${output}`);
+    } else {
+      console.log(`[db-schema-sync] \u2713 Schema unchanged at ${output}`);
+    }
+    emitSchemaSyncResult(result);
+    process.exitCode = 0;
   } catch (err) {
+    const result = generationFailure(err);
     console.error(
-      `[db-schema-sync] \u2717 Failed:`,
-      err instanceof Error ? err.message : String(err)
+      `[db-schema-sync] \u2717 Failed (${result.status}): ${result.message}`
     );
-    process.exit(1);
+    emitSchemaSyncResult(result);
+    process.exitCode = 1;
   }
 }
-main();
+if (isDirectExecution()) {
+  void main();
+}
+export {
+  main
+};

package/dist/{chunk-T3RIJCQD.js → chunk-EVOKG4DJ.js}

@@ -2673,10 +2673,15 @@ import {
   rmSync,
   writeFileSync
 } from "fs";
+import { createRequire as createNodeRequire } from "module";
 import { tmpdir } from "os";
-import { dirname, delimiter, join, resolve } from "path";
+import { dirname, delimiter, join, relative, resolve } from "path";
+var MAX_MESSAGE_LENGTH = 500;
+var MAX_DIAGNOSTIC_MESSAGE_LENGTH = 300;
+var MAX_DIAGNOSTIC_FILE_LENGTH = 160;
+var MAX_DIAGNOSTIC_SUMMARY_COUNT = 5;
 function truncateMessage(message) {
-  return message.length > 500 ? `${message.slice(0, 500)}...` : message;
+  return message.length > MAX_MESSAGE_LENGTH ? `${message.slice(0, MAX_MESSAGE_LENGTH)}...` : message;
 }
 function result(params, startTime) {
   return {
@@ -2917,6 +2922,320 @@ function validateGeneratedSchema(options) {
     );
   }
 }
+function compatibilityUnavailable(message, removedExportCount = 0) {
+  return {
+    ok: false,
+    status: "unavailable",
+    removedExportCount,
+    oldDiagnosticCount: 0,
+    candidateDiagnosticCount: 0,
+    newDiagnosticCount: 0,
+    diagnosticSummary: [],
+    message: truncateMessage(message)
+  };
+}
+function loadProjectTypeScript(cwd) {
+  const projectRequire = createNodeRequire(join(cwd, "package.json"));
+  return projectRequire("typescript");
+}
+function resolveConsumerProjectPath(cwd, project) {
+  if (project) return resolve(cwd, project);
+  const projectPath = resolve(cwd, "tsconfig.node.json");
+  return existsSync(projectPath) ? projectPath : void 0;
+}
+function canonicalPath(path) {
+  const absolute = resolve(path).replace(/\\/g, "/");
+  return process.platform === "win32" ? absolute.toLowerCase() : absolute;
+}
+function hasExportModifier(ts, node) {
+  const modifiers = node.modifiers;
+  return Boolean(
+    modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)
+  );
+}
+function collectBindingNames(ts, name, names) {
+  if (ts.isIdentifier(name)) {
+    names.add(name.text);
+    return;
+  }
+  for (const element of name.elements) {
+    if (!ts.isOmittedExpression(element)) {
+      collectBindingNames(ts, element.name, names);
+    }
+  }
+}
+function collectPublicExportNames(ts, source) {
+  const sourceFile = ts.createSourceFile(
+    "schema.ts",
+    source,
+    ts.ScriptTarget.Latest,
+    false,
+    ts.ScriptKind.TS
+  );
+  const names = /* @__PURE__ */ new Set();
+  let complete = true;
+  for (const statement of sourceFile.statements) {
+    if (ts.isExportDeclaration(statement)) {
+      if (!statement.exportClause) {
+        complete = false;
+      } else if (ts.isNamedExports(statement.exportClause)) {
+        for (const element of statement.exportClause.elements) {
+          names.add(element.name.text);
+        }
+      } else {
+        names.add(statement.exportClause.name.text);
+      }
+      continue;
+    }
+    if (ts.isExportAssignment(statement)) {
+      names.add("default");
+      continue;
+    }
+    if (!hasExportModifier(ts, statement)) continue;
+    if (ts.isVariableStatement(statement)) {
+      for (const declaration of statement.declarationList.declarations) {
+        collectBindingNames(ts, declaration.name, names);
+      }
+      continue;
+    }
+    if (ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement) || ts.isInterfaceDeclaration(statement) || ts.isTypeAliasDeclaration(statement) || ts.isEnumDeclaration(statement) || ts.isModuleDeclaration(statement)) {
+      if (statement.name) {
+        names.add(statement.name.text);
+      } else {
+        names.add("default");
+      }
+    }
+  }
+  return { names, complete };
+}
+function fallbackRemovedExportCount(oldSource, candidateSource) {
+  const declarationPattern = /^\s*export\s+(?:declare\s+)?(?:const|let|var|function|class|interface|type|enum|namespace|module)\s+([A-Za-z_$][\w$]*)/gm;
+  const collect = (source) => {
+    const names = /* @__PURE__ */ new Set();
+    for (const match of source.matchAll(declarationPattern)) {
+      names.add(match[1]);
+    }
+    return names;
+  };
+  const oldNames = collect(oldSource);
+  const candidateNames = collect(candidateSource);
+  return [...oldNames].filter((name) => !candidateNames.has(name)).length;
+}
+function createOverlayProgram(params) {
+  const target = canonicalPath(params.targetPath);
+  const host = params.ts.createCompilerHost(params.parsed.options, true);
+  const defaultFileExists = host.fileExists.bind(host);
+  const defaultReadFile = host.readFile.bind(host);
+  const defaultGetSourceFile = host.getSourceFile.bind(host);
+  const isTarget = (fileName) => canonicalPath(fileName) === target;
+  host.fileExists = (fileName) => isTarget(fileName) ? true : defaultFileExists(fileName);
+  host.readFile = (fileName) => isTarget(fileName) ? params.source : defaultReadFile(fileName);
+  host.getSourceFile = (fileName, languageVersion, onError, shouldCreate) => {
+    if (isTarget(fileName)) {
+      return params.ts.createSourceFile(
+        fileName,
+        params.source,
+        languageVersion,
+        true,
+        params.ts.ScriptKind.TS
+      );
+    }
+    return defaultGetSourceFile(
+      fileName,
+      languageVersion,
+      onError,
+      shouldCreate
+    );
+  };
+  return params.ts.createProgram({
+    rootNames: params.parsed.fileNames,
+    options: params.parsed.options,
+    projectReferences: params.parsed.projectReferences,
+    host
+  });
+}
+function isServerDiagnostic(diagnostic, cwd) {
+  if (!diagnostic.file) return true;
+  const path = relative(cwd, resolve(diagnostic.file.fileName)).replace(
+    /\\/g,
+    "/"
+  );
+  return path === "server" || path.startsWith("server/");
+}
+function normalizeDiagnostic(ts, diagnostic, cwd) {
+  const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, " ");
+  const file = diagnostic.file ? relative(cwd, resolve(diagnostic.file.fileName)).replace(/\\/g, "/") : void 0;
+  const position = diagnostic.file && diagnostic.start !== void 0 ? diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start) : void 0;
+  const line = position ? position.line + 1 : void 0;
+  const character = position ? position.character + 1 : void 0;
+  const key = [
+    diagnostic.code,
+    diagnostic.category,
+    file ?? "",
+    line ?? "",
+    character ?? "",
+    message
+  ].join("|");
+  return {
+    key,
+    summary: {
+      code: diagnostic.code,
+      file: file && file.length > MAX_DIAGNOSTIC_FILE_LENGTH ? `...${file.slice(-MAX_DIAGNOSTIC_FILE_LENGTH)}` : file,
+      line,
+      character,
+      message: message.length > MAX_DIAGNOSTIC_MESSAGE_LENGTH ? `${message.slice(0, MAX_DIAGNOSTIC_MESSAGE_LENGTH)}...` : message
+    }
+  };
+}
+function getServerDiagnostics(ts, program, cwd) {
+  return ts.getPreEmitDiagnostics(program).filter((diagnostic) => isServerDiagnostic(diagnostic, cwd));
+}
+function getNewDiagnostics(params) {
+  const oldCounts = /* @__PURE__ */ new Map();
+  for (const diagnostic of params.oldDiagnostics) {
+    const { key } = normalizeDiagnostic(params.ts, diagnostic, params.cwd);
+    oldCounts.set(key, (oldCounts.get(key) ?? 0) + 1);
+  }
+  const additions = [];
+  for (const diagnostic of params.candidateDiagnostics) {
+    const normalized = normalizeDiagnostic(params.ts, diagnostic, params.cwd);
+    const oldCount = oldCounts.get(normalized.key) ?? 0;
+    if (oldCount > 0) {
+      oldCounts.set(normalized.key, oldCount - 1);
+    } else {
+      additions.push(normalized);
+    }
+  }
+  additions.sort((left, right) => left.key.localeCompare(right.key));
+  return additions.map((addition) => addition.summary);
+}
+function checkSchemaConsumerCompatibility(options) {
+  const cwd = resolve(options.cwd);
+  const targetPath = resolve(cwd, options.targetPath);
+  let ts;
+  try {
+    ts = options.typescript ?? loadProjectTypeScript(cwd);
+  } catch (error) {
+    return compatibilityUnavailable(
+      `Project TypeScript compiler is unavailable: ${error instanceof Error ? error.message : String(error)}`,
+      fallbackRemovedExportCount(options.oldSource, options.candidateSource)
+    );
+  }
+  let removedExportCount = 0;
+  try {
+    const oldExports = collectPublicExportNames(ts, options.oldSource);
+    const candidateExports = collectPublicExportNames(
+      ts,
+      options.candidateSource
+    );
+    removedExportCount = [...oldExports.names].filter(
+      (name) => !candidateExports.names.has(name)
+    ).length;
+    if (!oldExports.complete || !candidateExports.complete) {
+      return compatibilityUnavailable(
+        "Schema public exports could not be completely enumerated",
+        removedExportCount
+      );
+    }
+  } catch (error) {
+    return compatibilityUnavailable(
+      `Schema public exports could not be compared: ${error instanceof Error ? error.message : String(error)}`,
+      fallbackRemovedExportCount(options.oldSource, options.candidateSource)
+    );
+  }
+  const projectPath = resolveConsumerProjectPath(cwd, options.project);
+  if (!projectPath || !existsSync(projectPath)) {
+    return compatibilityUnavailable(
+      "tsconfig.node.json is required for schema consumer compatibility checking",
+      removedExportCount
+    );
+  }
+  try {
+    const config = ts.readConfigFile(projectPath, ts.sys.readFile);
+    if (config.error) {
+      const message = ts.flattenDiagnosticMessageText(
+        config.error.messageText,
+        " "
+      );
+      return compatibilityUnavailable(
+        `Unable to read TypeScript project configuration: ${message}`,
+        removedExportCount
+      );
+    }
+    const parsed = ts.parseJsonConfigFileContent(
+      config.config,
+      ts.sys,
+      dirname(projectPath),
+      {
+        noEmit: true,
+        incremental: false,
+        composite: false
+      },
+      projectPath
+    );
+    if (parsed.errors.length > 0) {
+      const message = parsed.errors.slice(0, MAX_DIAGNOSTIC_SUMMARY_COUNT).map((error) => ts.flattenDiagnosticMessageText(error.messageText, " ")).join("; ");
+      return compatibilityUnavailable(
+        `Unable to parse TypeScript project configuration: ${message}`,
+        removedExportCount
+      );
+    }
+    const oldProgram = createOverlayProgram({
+      ts,
+      parsed,
+      targetPath,
+      source: options.oldSource
+    });
+    const candidateProgram = createOverlayProgram({
+      ts,
+      parsed,
+      targetPath,
+      source: options.candidateSource
+    });
+    const oldDiagnostics = getServerDiagnostics(ts, oldProgram, cwd);
+    const candidateDiagnostics = getServerDiagnostics(
+      ts,
+      candidateProgram,
+      cwd
+    );
+    const newDiagnostics = getNewDiagnostics({
+      ts,
+      cwd,
+      oldDiagnostics,
+      candidateDiagnostics
+    });
+    const diagnosticSummary = newDiagnostics.slice(
+      0,
+      MAX_DIAGNOSTIC_SUMMARY_COUNT
+    );
+    if (newDiagnostics.length > 0) {
+      return {
+        ok: false,
+        status: "incompatible",
+        removedExportCount,
+        oldDiagnosticCount: oldDiagnostics.length,
+        candidateDiagnosticCount: candidateDiagnostics.length,
+        newDiagnosticCount: newDiagnostics.length,
+        diagnosticSummary,
+        message: "Candidate schema introduces new server TypeScript diagnostics"
+      };
+    }
+    return {
+      ok: true,
+      status: "compatible",
+      removedExportCount,
+      oldDiagnosticCount: oldDiagnostics.length,
+      candidateDiagnosticCount: candidateDiagnostics.length,
+      newDiagnosticCount: 0,
+      diagnosticSummary: []
+    };
+  } catch (error) {
+    return compatibilityUnavailable(
+      `Schema consumer compatibility check failed: ${error instanceof Error ? error.message : String(error)}`,
+      removedExportCount
+    );
+  }
+}
 
 // src/index.ts
 async function generateSchema(options) {
@@ -2942,6 +3261,7 @@ export {
   normalizeApiResponse,
   generateSchemaCode,
   validateGeneratedSchema,
+  checkSchemaConsumerCompatibility,
   generateSchema,
   generateSchemaFromData
 };

package/dist/index.js

@@ -6,7 +6,7 @@ import {
   normalizeApiResponse,
   resolveEnvOptions,
   validateGeneratedSchema
-} from "./chunk-T3RIJCQD.js";
+} from "./chunk-EVOKG4DJ.js";
 export {
   generateSchema,
   generateSchemaCode,

package/package.json

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