nextly 0.0.1 → 0.0.2-alpha.0

package/dist/chunk-VJ66NCL4.mjs

@@ -0,0 +1,193 @@
+import {
+  PromptCancelledError,
+  TTYRequiredError
+} from "./chunk-AK6Z23OX.mjs";
+
+// src/domains/schema/pipeline/prompt-dispatcher/clack-terminal.ts
+import * as clack from "@clack/prompts";
+function hasTTY() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+var ClackTerminalPromptDispatcher = class {
+  async dispatch(args) {
+    const { candidates, events } = args;
+    if (candidates.length === 0 && events.length === 0) {
+      return { confirmedRenames: [], resolutions: [], proceed: true };
+    }
+    if (!hasTTY()) {
+      const renameSample = candidates.slice(0, 3).map((c) => `${c.fromColumn} -> ${c.toColumn} on ${c.tableName}`).join(", ");
+      const eventSample = events.slice(0, 3).map(
+        (e) => e.kind === "type_change" ? `type change on ${e.tableName}.${e.columnName} (${e.fromType} -> ${e.toType})` : `${e.kind === "add_not_null_with_nulls" ? "NOT NULL on" : "required field"} ${e.tableName}.${e.columnName}`
+      ).join(", ");
+      const parts = [];
+      if (candidates.length > 0) {
+        parts.push(`${candidates.length} rename candidate(s): ${renameSample}`);
+      }
+      if (events.length > 0) {
+        parts.push(`${events.length} resolution event(s): ${eventSample}`);
+      }
+      throw new TTYRequiredError(
+        // Multi-line so log readers can scan rename vs event sections
+        // separately without an arbitrary semicolon-join.
+        `Schema change needs confirmation.
+${parts.join("\n")}`
+      );
+    }
+    const renameResult = candidates.length > 0 ? await this.runShrinkingPoolPrompts(candidates) : {
+      confirmedRenames: [],
+      resolutions: [],
+      proceed: true
+    };
+    if (!renameResult.proceed) return renameResult;
+    const eventResult = await this.runEventPrompts(events);
+    return {
+      confirmedRenames: renameResult.confirmedRenames,
+      resolutions: eventResult.resolutions,
+      proceed: eventResult.proceed
+    };
+  }
+  // Walk classifier events in order. NOT-NULL kinds get a multi-step
+  // (select kind -> text value if provide_default -> next event); type_change
+  // gets a single warning + Y/N. Any abort or cancel returns proceed=false.
+  async runEventPrompts(events) {
+    if (events.length === 0) {
+      return { resolutions: [], proceed: true };
+    }
+    const resolutions = [];
+    clack.intro("Schema change requires confirmation");
+    for (const event of events) {
+      if (event.kind === "type_change") {
+        clack.note(
+          [
+            event.perDialectWarning.pg,
+            event.perDialectWarning.mysql,
+            event.perDialectWarning.sqlite
+          ].join("\n"),
+          `Type change on ${event.tableName}.${event.columnName}: ${event.fromType} -> ${event.toType}`
+        );
+        const proceed = await clack.confirm({
+          message: `Proceed with type change on ${event.tableName}.${event.columnName}?`,
+          initialValue: false
+        });
+        if (clack.isCancel(proceed) || proceed === false) {
+          clack.outro("Cancelled");
+          return { resolutions, proceed: false };
+        }
+        continue;
+      }
+      const headline = event.kind === "add_not_null_with_nulls" ? `Adding NOT NULL to "${event.tableName}.${event.columnName}"
+${event.nullCount} of ${event.tableRowCount} rows have NULL values.` : `New required field "${event.tableName}.${event.columnName}" on table with ${event.tableRowCount} existing rows.`;
+      clack.note(headline, "Resolution needed");
+      const labels = {
+        provide_default: "Provide a default value for empty rows",
+        make_optional: "Make the field optional (cancel the NOT NULL)",
+        delete_nonconforming: event.kind === "add_not_null_with_nulls" ? `Delete the ${event.nullCount} rows with empty values` : "Delete rows that violate the constraint",
+        abort: "Cancel everything"
+      };
+      const options = event.applicableResolutions.map((kind2) => ({
+        value: kind2,
+        label: labels[kind2]
+      }));
+      const choice = await clack.select({
+        message: "How do you want to handle this?",
+        options
+      });
+      if (clack.isCancel(choice)) {
+        clack.outro("Cancelled");
+        return { resolutions, proceed: false };
+      }
+      const kind = choice;
+      if (kind === "abort") {
+        clack.outro("Cancelled");
+        return { resolutions, proceed: false };
+      }
+      if (kind === "provide_default") {
+        const value = await clack.text({
+          message: `Default value for "${event.columnName}":`,
+          validate: (v) => !v || v.trim().length === 0 ? "Cannot be empty" : void 0
+        });
+        if (clack.isCancel(value)) {
+          clack.outro("Cancelled");
+          return { resolutions, proceed: false };
+        }
+        resolutions.push({
+          kind: "provide_default",
+          eventId: event.id,
+          value
+        });
+      } else {
+        resolutions.push({ kind, eventId: event.id });
+      }
+    }
+    clack.outro("Resolutions confirmed");
+    return { resolutions, proceed: true };
+  }
+  // Walks candidates in a shrinking-pool pattern:
+  //   1. Group candidates by `fromColumn` (the dropped column).
+  //   2. For each unique drop, ask the user to pick from its valid adds
+  //      (filtered to those that haven't been consumed).
+  //   3. If user picks 'rename' with a specific add, mark both the drop
+  //      and the add as consumed; future prompts skip them.
+  //   4. If user picks 'drop_and_add', drop survives as drop+add (no rename).
+  async runShrinkingPoolPrompts(candidates) {
+    const consumedDrops = /* @__PURE__ */ new Set();
+    const consumedAdds = /* @__PURE__ */ new Set();
+    const confirmed = [];
+    const dropToOptions = /* @__PURE__ */ new Map();
+    for (const c of candidates) {
+      const key = `${c.tableName}::${c.fromColumn}`;
+      const list = dropToOptions.get(key) ?? [];
+      list.push(c);
+      dropToOptions.set(key, list);
+    }
+    clack.intro("Schema rename detected");
+    for (const [dropKey, options] of dropToOptions) {
+      if (consumedDrops.has(dropKey)) continue;
+      const remaining = options.filter((c) => {
+        const addKey = `${c.tableName}::${c.toColumn}`;
+        return !consumedAdds.has(addKey);
+      });
+      if (remaining.length === 0) continue;
+      const first = remaining[0];
+      const selectOptions = remaining.map((c) => ({
+        value: `rename:${c.toColumn}`,
+        label: `Rename ${c.fromColumn} -> ${c.toColumn}`,
+        hint: c.typesCompatible ? `${c.fromType} -> ${c.toType} (data preserved)` : `${c.fromType} -> ${c.toType} (incompatible types; not recommended)`
+      }));
+      selectOptions.push({
+        value: "drop_and_add",
+        label: `Drop ${first.fromColumn} and add new column(s) (data lost)`
+      });
+      const compatible = remaining.find((c) => c.typesCompatible);
+      const initialValue = compatible !== void 0 ? `rename:${compatible.toColumn}` : "drop_and_add";
+      const choice = await clack.select({
+        message: `Column "${first.fromColumn}" was removed in ${first.tableName}. What should happen?`,
+        options: selectOptions,
+        initialValue
+      });
+      if (clack.isCancel(choice)) {
+        clack.outro("Cancelled");
+        throw new PromptCancelledError();
+      }
+      if (typeof choice === "string" && choice.startsWith("rename:")) {
+        const targetColumn = choice.slice("rename:".length);
+        const picked = remaining.find((c) => c.toColumn === targetColumn);
+        if (picked) {
+          confirmed.push(picked);
+          consumedDrops.add(dropKey);
+          consumedAdds.add(`${picked.tableName}::${picked.toColumn}`);
+        }
+      }
+    }
+    clack.outro("Schema renames confirmed");
+    return {
+      confirmedRenames: confirmed,
+      resolutions: [],
+      proceed: true
+    };
+  }
+};
+
+export {
+  ClackTerminalPromptDispatcher
+};

package/dist/chunk-VQJQHVEV.mjs

@@ -0,0 +1,29 @@
+import {
+  NextlyError
+} from "./chunk-NRUWQ5Z7.mjs";
+
+// src/api/read-json-body.ts
+async function readJsonBody(req, extraLogContext) {
+  try {
+    return await req.json();
+  } catch {
+    throw new NextlyError({
+      code: "VALIDATION_ERROR",
+      publicMessage: "Validation failed.",
+      publicData: {
+        errors: [
+          {
+            path: "",
+            code: "invalid_json",
+            message: "Request body is not valid JSON."
+          }
+        ]
+      },
+      logContext: { reason: "invalid-json-body", ...extraLogContext }
+    });
+  }
+}
+
+export {
+  readJsonBody
+};

package/dist/chunk-VTJADRO3.mjs

@@ -0,0 +1,141 @@
+// src/shared/lib/pluralization.ts
+function isAlreadyPlural(word) {
+  const lower = word.toLowerCase();
+  const knownPlurals = [
+    "people",
+    "children",
+    "men",
+    "women",
+    "teeth",
+    "feet",
+    "mice",
+    "geese",
+    "oxen",
+    "sheep",
+    "deer",
+    "fish",
+    "species",
+    "series",
+    "crises",
+    "analyses",
+    "theses",
+    "phenomena",
+    "criteria",
+    "data",
+    "alumni",
+    "cacti",
+    "fungi",
+    "nuclei",
+    "radii"
+  ];
+  if (knownPlurals.includes(lower)) return true;
+  if (lower.endsWith("ies")) return true;
+  if (lower.endsWith("ves")) return true;
+  if (lower.endsWith("en")) {
+    const beforeEN = lower.slice(-3, -2);
+    if (beforeEN && !/[aeiou]/.test(beforeEN)) {
+      if (lower === "oxen" || lower === "children") return true;
+    }
+  }
+  if (lower.endsWith("i") && lower.length > 2) {
+    const beforeI = lower.slice(-2, -1);
+    if (["c", "g", "l", "r"].includes(beforeI)) {
+      return true;
+    }
+  }
+  if (lower.endsWith("a") && lower.length > 2) {
+    const beforeA = lower.slice(-2, -1);
+    if (["n", "r"].includes(beforeA)) {
+      return true;
+    }
+  }
+  if (lower.endsWith("oes")) {
+    return true;
+  }
+  if (lower.endsWith("s") && lower.length > 1 && !isLikelySingular(lower)) {
+    return true;
+  }
+  return false;
+}
+function isLikelySingular(word) {
+  const lower = word.toLowerCase();
+  const singularEndings = [
+    "ss",
+    "us",
+    "is",
+    "os",
+    "sis",
+    "asis",
+    "isis",
+    "ysis",
+    "tis",
+    "itis",
+    "esis"
+  ];
+  for (const ending of singularEndings) {
+    if (lower.endsWith(ending)) return true;
+  }
+  const knowSingulars = [
+    "glass",
+    "class",
+    "mass",
+    "pass",
+    "grass",
+    "status",
+    "atlas",
+    "bus",
+    "gas",
+    "lens",
+    "canvas",
+    "process",
+    "address",
+    "access",
+    "success",
+    "princess",
+    "actress",
+    "hostess",
+    "witness",
+    "fortress",
+    "express"
+  ];
+  if (knowSingulars.includes(lower)) return true;
+  return false;
+}
+function simplePluralize(singular) {
+  const normalized = singular.trim();
+  if (!normalized) return "";
+  if (isAlreadyPlural(normalized)) {
+    return normalized;
+  }
+  if (normalized.endsWith("s") || normalized.endsWith("x") || normalized.endsWith("z")) {
+    return normalized + "es";
+  }
+  if (normalized.endsWith("y") && !/[aeiou]y$/i.test(normalized)) {
+    return normalized.slice(0, -1) + "ies";
+  }
+  return normalized + "s";
+}
+function toSingularLabel(slug) {
+  const words = slug.split(/[-_]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase());
+  const lastWord = words[words.length - 1];
+  if (lastWord.endsWith("s") && lastWord.length > 1) {
+    if (!isLikelySingular(lastWord)) {
+      words[words.length - 1] = lastWord.slice(0, -1);
+    }
+  }
+  return words.join(" ");
+}
+function toPluralLabel(slug) {
+  const words = slug.split(/[-_]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase());
+  const lastWord = words[words.length - 1];
+  if (lastWord && !isAlreadyPlural(lastWord)) {
+    words[words.length - 1] = simplePluralize(lastWord);
+  }
+  return words.join(" ");
+}
+
+export {
+  simplePluralize,
+  toSingularLabel,
+  toPluralLabel
+};

package/dist/chunk-W4MGXIRR.mjs

@@ -0,0 +1,27 @@
+// src/observability/logger.ts
+var defaultLogger = {
+  error: (p) => console.error(
+    JSON.stringify({ level: "error", ts: (/* @__PURE__ */ new Date()).toISOString(), ...p })
+  ),
+  warn: (p) => console.warn(
+    JSON.stringify({ level: "warn", ts: (/* @__PURE__ */ new Date()).toISOString(), ...p })
+  ),
+  info: (p) => console.info(
+    JSON.stringify({ level: "info", ts: (/* @__PURE__ */ new Date()).toISOString(), ...p })
+  ),
+  debug: (p) => console.debug(
+    JSON.stringify({ level: "debug", ts: (/* @__PURE__ */ new Date()).toISOString(), ...p })
+  )
+};
+var currentLogger = defaultLogger;
+function setNextlyLogger(logger) {
+  currentLogger = logger ?? defaultLogger;
+}
+function getNextlyLogger() {
+  return currentLogger;
+}
+
+export {
+  setNextlyLogger,
+  getNextlyLogger
+};