nextly 0.0.1 → 0.0.2-alpha.0

package/dist/chunk-2OALJTK6.mjs

@@ -0,0 +1,489 @@
+import {
+  ClackTerminalPromptDispatcher
+} from "./chunk-VJ66NCL4.mjs";
+import {
+  extractDatabaseNameFromUrl
+} from "./chunk-KIMNCZGV.mjs";
+import {
+  DrizzleStatementExecutor,
+  PushSchemaPipeline,
+  RealPreCleanupExecutor,
+  createApplyDesiredSchema,
+  getProductionNotifier,
+  noopMigrationJournal,
+  noopPreRenameExecutor
+} from "./chunk-AK6Z23OX.mjs";
+import {
+  RealClassifier,
+  RegexRenameDetector,
+  buildDesiredTableFromFields,
+  diffSnapshots,
+  introspectLiveSnapshot
+} from "./chunk-SBACDPNX.mjs";
+import {
+  generateRuntimeSchema
+} from "./chunk-IZWPRDC3.mjs";
+
+// src/domains/schema/utils/resolve-table-name.ts
+function resolveCollectionTableName(slug, dbName) {
+  if (dbName && dbName.startsWith("dc_")) return dbName;
+  const base = dbName ?? slug;
+  return `dc_${base.replace(/-/g, "_")}`;
+}
+
+// src/init/reload-config.ts
+async function defaultResolver(name) {
+  const { getService } = await import("./register-SF6E6FVU.mjs");
+  return getService(name);
+}
+async function reloadNextlyConfig(opts) {
+  const resolverArg = opts?.resolver;
+  const resolve = (name) => resolverArg ? resolverArg(name) : defaultResolver(name);
+  let newConfig;
+  try {
+    const { loadConfig, clearConfigCache } = await import("./config-loader-23YEMC3Z.mjs");
+    clearConfigCache();
+    const result = await loadConfig();
+    newConfig = result.config;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const cause = err instanceof Error && err.cause instanceof Error ? err.cause.message : err instanceof Error && typeof err.cause === "string" ? err.cause : void 0;
+    const logContext = err && typeof err === "object" && "logContext" in err ? JSON.stringify(err.logContext) : void 0;
+    const detail = cause ? `${msg} (cause: ${cause})` : logContext ? `${msg} (context: ${logContext})` : msg;
+    console.warn(
+      `[Nextly HMR] Could not reload nextly.config.ts: ${detail}. Keeping the previously-loaded config. Fix the syntax error and save again to retry.`
+    );
+    return;
+  }
+  if (!newConfig) return;
+  let logger;
+  let adapter;
+  let migrationJournal;
+  try {
+    logger = await resolve("logger");
+    adapter = await resolve("adapter");
+    migrationJournal = await resolve("migrationJournal");
+  } catch {
+    return;
+  }
+  if (!adapter) return;
+  const dialect = adapter.dialect;
+  const db = adapter.getDrizzle();
+  const targets = [];
+  for (const c of newConfig.collections ?? []) {
+    if (!c.slug) continue;
+    targets.push({
+      slug: c.slug,
+      tableName: c.tableName ?? resolveCollectionTableName(c.slug, c.dbName),
+      fields: c.fields ?? [],
+      status: c.status === true
+    });
+  }
+  const singleTargets = [];
+  for (const s of newConfig.singles ?? []) {
+    if (!s.slug) continue;
+    const { resolveSingleTableName } = await import("./resolve-single-table-name-JSOMUB3R.mjs");
+    singleTargets.push({
+      slug: s.slug,
+      tableName: resolveSingleTableName({ slug: s.slug, dbName: s.dbName }),
+      fields: s.fields ?? [],
+      status: s.status === true
+    });
+  }
+  const componentTargets = [];
+  for (const c of newConfig.components ?? []) {
+    if (!c.slug) continue;
+    componentTargets.push({
+      slug: c.slug,
+      tableName: `comp_${c.slug.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "")}`,
+      fields: c.fields ?? []
+    });
+  }
+  if (targets.length === 0 && singleTargets.length === 0 && componentTargets.length === 0) return;
+  let liveSnapshot;
+  try {
+    liveSnapshot = await introspectLiveSnapshot(
+      db,
+      dialect,
+      [
+        ...targets.map((t) => t.tableName),
+        ...singleTargets.map((t) => t.tableName),
+        ...componentTargets.map((t) => t.tableName)
+      ]
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    logger?.error(
+      `[Nextly HMR] Could not introspect live schema: ${msg}. No code-first schema changes were applied this cycle.`
+    );
+    return;
+  }
+  const liveByTable = /* @__PURE__ */ new Map();
+  for (const t of liveSnapshot.tables) liveByTable.set(t.name, t);
+  let hasChanges = false;
+  const desiredCollections = {};
+  for (const target of targets) {
+    const entry = {
+      slug: target.slug,
+      tableName: target.tableName,
+      fields: target.fields,
+      status: target.status === true
+    };
+    try {
+      const live = liveByTable.has(target.tableName) ? { tables: [liveByTable.get(target.tableName)] } : { tables: [] };
+      const desiredTable = buildDesiredTableFromFields(
+        target.tableName,
+        target.fields,
+        dialect,
+        { hasStatus: target.status === true }
+      );
+      const operations = diffSnapshots(live, { tables: [desiredTable] });
+      if (operations.length === 0) {
+        desiredCollections[target.slug] = entry;
+        continue;
+      }
+      const classification = classifyForCodeFirst(operations, dialect);
+      if (!classification.safe) {
+        logger?.warn(
+          `[Nextly HMR] Code-first change for '${target.slug}' needs review (${classification.reason}). Auto-apply skipped to prevent data loss without explicit resolutions. Use the admin Schema Builder to confirm with resolutions, or revert the config edit.`
+        );
+        desiredCollections[target.slug] = entry;
+        continue;
+      }
+      hasChanges = true;
+      desiredCollections[target.slug] = entry;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      logger?.warn(
+        `[Nextly HMR] Skipping '${target.slug}' due to error during diff: ${msg}`
+      );
+    }
+  }
+  const desiredSingles = {};
+  for (const target of singleTargets) {
+    const entry = {
+      slug: target.slug,
+      tableName: target.tableName,
+      fields: target.fields,
+      status: target.status === true
+    };
+    try {
+      const live = liveByTable.has(target.tableName) ? { tables: [liveByTable.get(target.tableName)] } : { tables: [] };
+      const desiredTable = buildDesiredTableFromFields(
+        target.tableName,
+        target.fields,
+        dialect,
+        { hasStatus: target.status === true }
+      );
+      const operations = diffSnapshots(live, { tables: [desiredTable] });
+      if (operations.length === 0) {
+        desiredSingles[target.slug] = entry;
+        continue;
+      }
+      const classification = classifyForCodeFirst(operations, dialect);
+      if (!classification.safe) {
+        logger?.warn(
+          `[Nextly HMR] Code-first change for single '${target.slug}' needs review (${classification.reason}). Auto-apply skipped. Use the admin Schema Builder to confirm with resolutions, or revert the config edit.`
+        );
+        desiredSingles[target.slug] = entry;
+        continue;
+      }
+      hasChanges = true;
+      desiredSingles[target.slug] = entry;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      logger?.warn(
+        `[Nextly HMR] Skipping single '${target.slug}' due to error during diff: ${msg}`
+      );
+    }
+  }
+  const desiredComponents = {};
+  for (const target of componentTargets) {
+    const entry = {
+      slug: target.slug,
+      tableName: target.tableName,
+      fields: target.fields
+    };
+    try {
+      const live = liveByTable.has(target.tableName) ? { tables: [liveByTable.get(target.tableName)] } : { tables: [] };
+      const desiredTable = buildDesiredTableFromFields(
+        target.tableName,
+        target.fields,
+        dialect
+      );
+      const operations = diffSnapshots(live, { tables: [desiredTable] });
+      if (operations.length === 0) {
+        desiredComponents[target.slug] = entry;
+        continue;
+      }
+      const classification = classifyForCodeFirst(operations, dialect);
+      if (!classification.safe) {
+        logger?.warn(
+          `[Nextly HMR] Code-first change for component '${target.slug}' needs review (${classification.reason}). Auto-apply skipped. Use the admin Schema Builder to confirm with resolutions, or revert the config edit.`
+        );
+        desiredComponents[target.slug] = entry;
+        continue;
+      }
+      hasChanges = true;
+      desiredComponents[target.slug] = entry;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      logger?.warn(
+        `[Nextly HMR] Skipping component '${target.slug}' due to error during diff: ${msg}`
+      );
+    }
+  }
+  if (!hasChanges) return;
+  const databaseName = dialect === "mysql" ? extractDatabaseNameFromUrl(process.env.DATABASE_URL) : void 0;
+  const desired = {
+    collections: desiredCollections,
+    singles: desiredSingles,
+    components: desiredComponents
+  };
+  const promptDispatcher = opts?.dispatcher ?? new ClackTerminalPromptDispatcher();
+  const apply = createApplyDesiredSchema({
+    applyPipeline: (desiredArg, sourceArg, channelArg) => {
+      const pipeline = new PushSchemaPipeline({
+        executor: new DrizzleStatementExecutor(dialect, db),
+        renameDetector: new RegexRenameDetector(),
+        // F5 PR 5: real classifier emits add_not_null_with_nulls,
+        // add_required_field_no_default, and type_change events from the
+        // typed Operation[] stream. ClackTerminalPromptDispatcher renders
+        // them in the terminal; RealPreCleanupExecutor runs UPDATE/DELETE.
+        classifier: new RealClassifier(),
+        promptDispatcher,
+        preRenameExecutor: noopPreRenameExecutor,
+        preCleanupExecutor: new RealPreCleanupExecutor(),
+        // F8 PR 5: real journal from DI; falls back to noop if DI
+        // hasn't registered it yet (very-early HMR cycles).
+        migrationJournal: migrationJournal ?? noopMigrationJournal,
+        // F10 PR 3: HMR applies print a terminal box + write the
+        // NDJSON line. Same singleton across HMR cycles.
+        notifier: getProductionNotifier()
+      });
+      return pipeline.apply({
+        desired: desiredArg,
+        db,
+        dialect,
+        source: sourceArg,
+        promptChannel: channelArg,
+        databaseName
+      });
+    },
+    // Unused for source='code' — HMR skips the version check.
+    readSchemaVersionForSlug: () => Promise.resolve(null),
+    // Unused for HMR — we don't surface bumped versions in the log.
+    readNewSchemaVersionsForSlugs: () => Promise.resolve({})
+  });
+  const applyResult = await apply(desired, "code", {
+    promptChannel: "terminal"
+  });
+  if (applyResult.success) {
+    try {
+      const registry = await resolve(
+        "collectionRegistryService"
+      );
+      const codeFirstConfigs = (newConfig.collections ?? []).filter((c) => !!c.slug).map((c) => ({
+        slug: c.slug,
+        labels: {
+          singular: c.labels?.singular ?? c.slug,
+          plural: c.labels?.plural ?? `${c.slug}s`
+        },
+        fields: c.fields ?? [],
+        description: c.description,
+        tableName: c.dbName,
+        timestamps: c.timestamps,
+        admin: c.admin,
+        // Forward the Draft/Published flag so a code-first toggle reaches
+        // syncCodeFirstCollections and persists to dynamic_collections.status.
+        status: c.status === true
+      }));
+      await registry.syncCodeFirstCollections(codeFirstConfigs);
+    } catch {
+    }
+    try {
+      const singleReg = await resolve(
+        "singleRegistryService"
+      );
+      const codeFirstSingleConfigs = (newConfig.singles ?? []).filter((s) => !!s.slug).map((s) => {
+        const labelStr = typeof s.label === "string" ? s.label : s.label?.singular ?? s.slug.split(/[-_]/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+        return {
+          slug: s.slug,
+          label: labelStr,
+          fields: s.fields ?? [],
+          description: s.description,
+          tableName: s.dbName,
+          admin: s.admin,
+          // Forward Draft/Published flag for code-first Singles too.
+          status: s.status === true
+        };
+      });
+      if (codeFirstSingleConfigs.length > 0) {
+        await singleReg.syncCodeFirstSingles(codeFirstSingleConfigs);
+        for (const target of singleTargets) {
+          if (!liveByTable.has(target.tableName)) {
+            try {
+              await singleReg.updateMigrationStatus(target.slug, "applied");
+            } catch {
+            }
+          }
+        }
+      }
+    } catch {
+    }
+    try {
+      const compReg = await resolve(
+        "componentRegistryService"
+      );
+      const codeFirstComponentConfigs = (newConfig.components ?? []).filter((c) => !!c.slug).map((c) => {
+        const labelStr = typeof c.label === "string" ? c.label : c.label?.singular ?? c.slug.split(/[-_]/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+        return {
+          slug: c.slug,
+          label: labelStr,
+          fields: c.fields ?? [],
+          description: c.description,
+          admin: c.admin
+        };
+      });
+      if (codeFirstComponentConfigs.length > 0) {
+        await compReg.syncCodeFirstComponents(codeFirstComponentConfigs);
+      }
+    } catch {
+    }
+    const collectionFreshTables = /* @__PURE__ */ new Map();
+    const singleFreshTables = /* @__PURE__ */ new Map();
+    const componentFreshTables = /* @__PURE__ */ new Map();
+    try {
+      for (const c of Object.values(desiredCollections)) {
+        const { table } = generateRuntimeSchema(
+          c.tableName,
+          c.fields,
+          dialect,
+          { status: c.status === true }
+        );
+        collectionFreshTables.set(c.tableName, table);
+      }
+      for (const s of Object.values(desiredSingles)) {
+        const { table } = generateRuntimeSchema(
+          s.tableName,
+          s.fields,
+          dialect,
+          { status: s.status === true }
+        );
+        singleFreshTables.set(s.tableName, table);
+      }
+      for (const comp of Object.values(desiredComponents)) {
+        const { table } = generateRuntimeSchema(
+          comp.tableName,
+          comp.fields,
+          dialect
+        );
+        componentFreshTables.set(comp.tableName, table);
+      }
+    } catch {
+    }
+    try {
+      const schemaReg = await resolve("schemaRegistry");
+      for (const [tableName, table] of collectionFreshTables) {
+        schemaReg.registerDynamicSchema(tableName, table);
+      }
+      for (const [tableName, table] of singleFreshTables) {
+        schemaReg.registerDynamicSchema(tableName, table);
+      }
+      for (const [tableName, table] of componentFreshTables) {
+        schemaReg.registerDynamicSchema(tableName, table);
+      }
+    } catch {
+    }
+    try {
+      const collHandler = await resolve(
+        "collectionsHandler"
+      );
+      for (const [tableName, table] of collectionFreshTables) {
+        collHandler.refreshCollectionSchema(tableName, table);
+      }
+    } catch {
+    }
+    try {
+      const { broadcastDevReload } = await import("./dev-reload-broadcaster-B73IQ53V.mjs");
+      broadcastDevReload();
+    } catch {
+    }
+  }
+  if (!applyResult.success) {
+    const code = applyResult.error.code;
+    if (code === "CONFIRMATION_REQUIRED_NO_TTY") {
+      const detail = applyResult.error.message.replace(/^TTY required for schema confirmation\.\s*/i, "").replace(
+        /\s*Run from an interactive terminal,.*$/i,
+        ""
+      ).trim();
+      console.warn(
+        `
+[Nextly] Schema change needs your confirmation:
+  ${detail}
+
+Renames + drops auto-apply only when you confirm them.
+To apply, run one of:
+  \u2022 pnpm nextly db:sync         (prompts in this terminal)
+  \u2022 pnpm nextly migrate:create  (generates a committable migration)
+  \u2022 Use the admin UI Schema Builder at /admin
+
+Pure-additive changes (new fields, new collections) apply
+automatically on dev start; only structural changes need
+explicit confirmation.
+`
+      );
+    } else {
+      logger?.error(
+        `[Nextly HMR] Batch apply failed (${code}): ${applyResult.error.message}`
+      );
+    }
+  }
+}
+function classifyForCodeFirst(operations, _dialect) {
+  if (operations.length === 0) return { safe: true };
+  const dropsPerTable = /* @__PURE__ */ new Map();
+  const addsPerTable = /* @__PURE__ */ new Map();
+  for (const op of operations) {
+    if (op.type === "drop_column") {
+      dropsPerTable.set(
+        op.tableName,
+        (dropsPerTable.get(op.tableName) ?? 0) + 1
+      );
+    } else if (op.type === "add_column") {
+      addsPerTable.set(op.tableName, (addsPerTable.get(op.tableName) ?? 0) + 1);
+    }
+  }
+  const reasons = [];
+  for (const [t, drops] of dropsPerTable) {
+    const adds = addsPerTable.get(t) ?? 0;
+    if (drops > adds) {
+      const surplus = drops - adds;
+      reasons.push(
+        adds === 0 ? `drops ${drops} column(s) from '${t}' with no replacement(s); ${surplus} cannot be renamed without data loss` : `drops ${drops} columns from '${t}' but only ${adds} replacement(s); at least ${surplus} cannot be renamed without data loss`
+      );
+    }
+  }
+  for (const op of operations) {
+    if (op.type === "drop_table") {
+      reasons.push(`drops table '${op.tableName}'`);
+    } else if (op.type === "change_column_type") {
+      reasons.push(
+        `changes column '${op.columnName}' type from '${op.fromType}' to '${op.toType}'`
+      );
+    } else if (op.type === "change_column_nullable" && !op.toNullable) {
+      reasons.push(
+        `adds NOT NULL to column '${op.columnName}' (would fail on existing rows without a default)`
+      );
+    }
+  }
+  if (reasons.length > 0) {
+    return { safe: false, reason: reasons.join("; ") };
+  }
+  return { safe: true };
+}
+
+export {
+  resolveCollectionTableName,
+  reloadNextlyConfig
+};