@saasicat/cli 0.26.1 → 1.0.0-rc.0

package/dist/index.js

@@ -1,14 +1,14 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
-// src/tokens.ts
-var CLI_CONTEXT_CONFIG_TOKEN = /* @__PURE__ */ Symbol.for("saas-platform-cli/Config");
-var USER_PORT_TOKEN = /* @__PURE__ */ Symbol.for("saas-platform-cli/UserPort");
-var USER_MANAGEMENT_PORT_TOKEN = /* @__PURE__ */ Symbol.for("saas-platform-cli/UserManagementPort");
-var AUDIT_QUERY_PORT_TOKEN = /* @__PURE__ */ Symbol.for("saas-platform-cli/AuditQueryPort");
-var DOCTOR_CHECKS_TOKEN = /* @__PURE__ */ Symbol.for("saas-platform-cli/DoctorChecks");
-var MANIFEST_ACCESS_PORT_TOKEN = /* @__PURE__ */ Symbol.for("saas-platform-cli/ManifestAccessPort");
-var MANIFEST_CHECKS_TOKEN = /* @__PURE__ */ Symbol.for("saas-platform-cli/ManifestChecks");
+// src/cli.tokens.ts
+var CLI_CONTEXT_CONFIG_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/cli/Config");
+var USER_PORT_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/cli/UserPort");
+var USER_MANAGEMENT_PORT_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/cli/UserManagementPort");
+var AUDIT_QUERY_PORT_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/cli/AuditQueryPort");
+var DOCTOR_CHECKS_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/cli/DoctorChecks");
+var MANIFEST_ACCESS_PORT_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/cli/ManifestAccessPort");
+var MANIFEST_CHECKS_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/cli/ManifestChecks");
 
 // src/cli-context.service.ts
 import * as os from "os";
@@ -1072,21 +1072,21 @@ function structuralOnly(line) {
   return stripLineComment(blankStringLiterals(line));
 }
 __name(structuralOnly, "structuralOnly");
-function extractBlockNames(schema, keyword) {
+function extractBlockNames(schema2, keyword) {
   const pattern = declarationPattern(keyword);
   const names = [];
-  for (const line of schema.split("\n")) {
+  for (const line of schema2.split("\n")) {
     const match = structuralOnly(line).match(pattern);
     if (match) names.push(match[1]);
   }
   return names;
 }
 __name(extractBlockNames, "extractBlockNames");
-function extractBlocks(schema, keyword) {
+function extractBlocks(schema2, keyword) {
   const pattern = declarationPattern(keyword);
   const blocks = /* @__PURE__ */ new Map();
   let current = null;
-  for (const rawLine of schema.split("\n")) {
+  for (const rawLine of schema2.split("\n")) {
     const stripped = structuralOnly(rawLine);
     const openCount = (stripped.match(/\{/g) ?? []).length;
     const closeCount = (stripped.match(/\}/g) ?? []).length;
@@ -1121,16 +1121,16 @@ function blockBodyLines(block) {
 __name(blockBodyLines, "blockBodyLines");
 
 // src/schema-apply.ts
-function extractModelNames(schema) {
-  return extractBlockNames(schema, "model");
+function extractModelNames(schema2) {
+  return extractBlockNames(schema2, "model");
 }
 __name(extractModelNames, "extractModelNames");
 function extractModelBlocks(fragment) {
   return extractBlocks(fragment, "model");
 }
 __name(extractModelBlocks, "extractModelBlocks");
-function applyFragmentBlocks(schema, fragmentBlocks, options = {}) {
-  const existing = new Set(extractModelNames(schema));
+function applyFragmentBlocks(schema2, fragmentBlocks, options = {}) {
+  const existing = new Set(extractModelNames(schema2));
   const added = [];
   const skipped = [];
   const additions = [];
@@ -1146,7 +1146,7 @@ function applyFragmentBlocks(schema, fragmentBlocks, options = {}) {
     return {
       added,
       skipped,
-      schema
+      schema: schema2
     };
   }
   const header = options.fragmentLabel ? `
@@ -1158,7 +1158,7 @@ function applyFragmentBlocks(schema, fragmentBlocks, options = {}) {
 
 // Inserted by \`saasicat schema apply\`
 `;
-  const trimmedSchema = schema.endsWith("\n") ? schema : schema + "\n";
+  const trimmedSchema = schema2.endsWith("\n") ? schema2 : schema2 + "\n";
   return {
     added,
     skipped,
@@ -1216,15 +1216,15 @@ function parseBlockAttributes(name, block) {
   };
 }
 __name(parseBlockAttributes, "parseBlockAttributes");
-function parseSchema(schema) {
+function parseSchema(schema2) {
   const models = /* @__PURE__ */ new Map();
   const modelAttributes = /* @__PURE__ */ new Map();
-  for (const [name, block] of extractBlocks(schema, "model")) {
+  for (const [name, block] of extractBlocks(schema2, "model")) {
     models.set(name, parseFields(block));
     modelAttributes.set(name, parseBlockAttributes(name, block));
   }
   const enums = /* @__PURE__ */ new Map();
-  for (const [name, block] of extractBlocks(schema, "enum")) {
+  for (const [name, block] of extractBlocks(schema2, "enum")) {
     enums.set(name, parseEnumValues(block));
   }
   return {
@@ -1350,7 +1350,678 @@ function checkSchema(specSchema, appSchema) {
 }
 __name(checkSchema, "checkSchema");
 
-// src/module.ts
+// src/migration-constraints.ts
+var CONSTRAINTS_MARKER = "-- saasicat:constraints";
+function migrationCreatedBy(before, after) {
+  const existing = new Set(before);
+  const created = after.filter((name) => /^\d{14}_/.test(name) && !existing.has(name)).sort();
+  return created.length > 0 ? created[created.length - 1] : null;
+}
+__name(migrationCreatedBy, "migrationCreatedBy");
+function hasConstraints(migrationSql) {
+  return migrationSql.includes(CONSTRAINTS_MARKER);
+}
+__name(hasConstraints, "hasConstraints");
+function tablesAddressedBy(statement) {
+  return [
+    ...statement.matchAll(/\bON\s+"?(\w+)"?|\bALTER\s+TABLE\s+"?(\w+)"?/gi)
+  ].map((m) => m[1] ?? m[2]);
+}
+__name(tablesAddressedBy, "tablesAddressedBy");
+function constraintsFor(constraintsSql, tables) {
+  const known = new Set(tables);
+  return constraintsSql.split(/\n\s*\n/).filter((block) => {
+    const addressed = tablesAddressedBy(block);
+    return addressed.length === 0 || addressed.every((table) => known.has(table));
+  }).join("\n\n").trimEnd();
+}
+__name(constraintsFor, "constraintsFor");
+function appendConstraints(migrationSql, constraintsSql) {
+  if (hasConstraints(migrationSql)) return migrationSql;
+  if (constraintsSql.trim() === "") return migrationSql;
+  const body = migrationSql.endsWith("\n") ? migrationSql : `${migrationSql}
+`;
+  return `${body}
+${CONSTRAINTS_MARKER} \u2014 appended by \`saasicat schema migrate\`.
+-- Source: @saasicat/spec/sql/constraints.postgres.sql. These are part of the
+-- canonical schema: the adapter contract tests run against a database that has
+-- them. Edit the spec, not this copy.
+${constraintsSql.trimEnd()}
+`;
+}
+__name(appendConstraints, "appendConstraints");
+function reportConstraints(outcome, context) {
+  switch (outcome) {
+    case "appended":
+      return {
+        outcome,
+        mayApply: true,
+        message: `  + appended to ${context.migration}/migration.sql`
+      };
+    case "already-present":
+      return {
+        outcome,
+        mayApply: true,
+        message: `  = ${context.migration} already carries them.`
+      };
+    case "not-applicable":
+      return {
+        outcome,
+        mayApply: true,
+        message: "  = none of them apply to the tables in this schema."
+      };
+    case "no-migration":
+      return {
+        outcome,
+        mayApply: true,
+        message: "  = Prisma created no migration \u2014 nothing to append to, and nothing new to apply."
+      };
+    case "failed":
+      return {
+        outcome,
+        mayApply: false,
+        message: `  ! Could not append them, so the migration is incomplete. Add ${context.sqlPath} to it by hand, before applying it \u2014 nothing was applied.`
+      };
+  }
+}
+__name(reportConstraints, "reportConstraints");
+
+// src/fk-pointers.ts
+var POINTER = /^(\s*)\/\/\s*(\w+)(\s+)(Tenant|User)(\??)(\s+)(@relation\(.*\))\s*$/;
+function findFkPointers(schema2) {
+  const found = [];
+  let model = "";
+  schema2.split("\n").forEach((text, line) => {
+    const opening = /^model\s+(\w+)\s*\{/.exec(text);
+    if (opening) model = opening[1];
+    const match = POINTER.exec(text);
+    if (match) found.push({
+      line,
+      target: match[4],
+      model,
+      text
+    });
+  });
+  return found;
+}
+__name(findFkPointers, "findFkPointers");
+function relationNameOf(relationAttribute) {
+  const match = /@relation\(\s*"([^"]+)"/.exec(relationAttribute);
+  return match ? match[1] : null;
+}
+__name(relationNameOf, "relationNameOf");
+function escapeForRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+__name(escapeForRegExp, "escapeForRegExp");
+function modelBody(schema2, model) {
+  const name = escapeForRegExp(model);
+  const block = new RegExp(`(^|\\n)model\\s+${name}\\s*\\{([\\s\\S]*?)\\n\\}`, "m").exec(schema2);
+  return block ? block[2] : null;
+}
+__name(modelBody, "modelBody");
+function isOneToOne(schema2, model, foreignKey) {
+  const body = modelBody(schema2, model);
+  if (!body) return false;
+  return new RegExp(`^\\s*${escapeForRegExp(foreignKey)}\\s+\\S+.*@unique`, "m").test(body);
+}
+__name(isOneToOne, "isOneToOne");
+function hasBackRelation(schema2, model, owner, relationName, singular = false) {
+  const body = modelBody(schema2, owner);
+  if (body === null) return false;
+  const name = escapeForRegExp(model);
+  const shape = singular ? `${name}\\??` : `${name}\\[\\]`;
+  const candidates = [
+    ...body.matchAll(new RegExp(`^\\s*\\w+\\s+${shape}(\\s.*)?$`, "gm"))
+  ];
+  return candidates.some((line) => relationNameOf(line[0]) === relationName);
+}
+__name(hasBackRelation, "hasBackRelation");
+function enableFkPointers(schema2, models) {
+  const lines = schema2.split("\n");
+  const enabled = [];
+  const skipped = [];
+  const needsBackRelation = [];
+  for (const pointer of findFkPointers(schema2)) {
+    const model = pointer.target === "Tenant" ? models.tenant : models.user;
+    if (!model) {
+      skipped.push({
+        line: pointer.line,
+        target: pointer.target
+      });
+      continue;
+    }
+    const match = POINTER.exec(pointer.text);
+    const relationName = relationNameOf(match[7]);
+    const foreignKey = foreignKeyOf(match[7]);
+    const singular = foreignKey !== null && isOneToOne(schema2, pointer.model, foreignKey);
+    if (!hasBackRelation(schema2, pointer.model, model, relationName, singular)) {
+      needsBackRelation.push({
+        line: pointer.line,
+        owner: model,
+        suggestion: backRelationSuggestion(pointer.model, relationName, singular)
+      });
+      continue;
+    }
+    const [, indent, field, gap1, , optional, gap2, relation] = match;
+    lines[pointer.line] = `${indent}${field}${gap1}${model}${optional}${gap2}${relation}`;
+    enabled.push({
+      line: pointer.line,
+      model
+    });
+  }
+  return {
+    schema: lines.join("\n"),
+    enabled,
+    skipped,
+    needsBackRelation
+  };
+}
+__name(enableFkPointers, "enableFkPointers");
+var lowerFirst = /* @__PURE__ */ __name((value) => value.charAt(0).toLowerCase() + value.slice(1), "lowerFirst");
+function foreignKeyOf(relationAttribute) {
+  const match = /fields:\s*\[\s*(\w+)/.exec(relationAttribute);
+  return match ? match[1] : null;
+}
+__name(foreignKeyOf, "foreignKeyOf");
+function backRelationSuggestion(model, relationName, singular) {
+  const field = singular ? lowerFirst(model) : `${lowerFirst(model)}s`;
+  const type = singular ? `${model}?` : `${model}[]`;
+  return `${field} ${type}` + (relationName ? ` @relation("${relationName}")` : "");
+}
+__name(backRelationSuggestion, "backRelationSuggestion");
+function assertModelsExist(declaredModels, models) {
+  const missing = Object.entries(models).filter(([, name]) => name && !declaredModels.includes(name)).map(([role, name]) => `--${role}-model=${name}`);
+  if (missing.length === 0) return;
+  throw new Error(`${missing.join(", ")} \u2014 no such model in this schema. It declares: ${declaredModels.slice().sort().join(", ")}.`);
+}
+__name(assertModelsExist, "assertModelsExist");
+
+// src/init/catalog-keys.ts
+import { planCatalogSchema } from "@saasicat/spec";
+var schema = planCatalogSchema;
+function required(value, what) {
+  if (value === void 0) {
+    throw new Error(`plan-catalog.schema.json declares no ${what} \u2014 @saasicat/spec and @saasicat/cli are out of step.`);
+  }
+  return value;
+}
+__name(required, "required");
+function projectKeyPattern() {
+  return new RegExp(required(schema.properties?.projectKey?.pattern, "pattern for projectKey"));
+}
+__name(projectKeyPattern, "projectKeyPattern");
+function quotaKeyPattern() {
+  const patterns = Object.keys(required(schema.$defs?.PlanDef?.properties?.quotas?.patternProperties, "quota key pattern"));
+  if (patterns.length !== 1) {
+    throw new Error(`plan-catalog.schema.json declares ${patterns.length} quota key patterns; this derivation can express one.`);
+  }
+  return new RegExp(patterns[0]);
+}
+__name(quotaKeyPattern, "quotaKeyPattern");
+function minimumQuotasPerPlan() {
+  return required(schema.$defs?.PlanDef?.properties?.quotas?.minProperties, "minProperties");
+}
+__name(minimumQuotasPerPlan, "minimumQuotasPerPlan");
+function assertValidProjectKey(projectKey) {
+  const pattern = projectKeyPattern();
+  if (pattern.test(projectKey)) return;
+  throw new Error(`--project-key=${projectKey} is not a valid project key. It has to match ${pattern.source} \u2014 lower case, starting with a letter, at least two characters. The platform validates config/saas.yaml against the same pattern at boot, so this would fail after every file was written.`);
+}
+__name(assertValidProjectKey, "assertValidProjectKey");
+function assertValidQuotaKey(quotaKey) {
+  const pattern = quotaKeyPattern();
+  if (pattern.test(quotaKey)) return;
+  throw new Error(`--quota=${quotaKey}:\u2026 is not a valid quota key. It has to match ${pattern.source} \u2014 lower camel case, no separators, so \`activeSeats\` rather than \`active-seats\` or \`active_seats\`. The plan's \`quotas\` object forbids additional properties, so the platform rejects config/saas.yaml at boot otherwise.`);
+}
+__name(assertValidQuotaKey, "assertValidQuotaKey");
+
+// src/init/plan.ts
+function parseQuota(spec) {
+  const [key, model] = spec.split(":");
+  if (!key) throw new Error(`--quota needs a key: got '${spec}'`);
+  assertValidQuotaKey(key);
+  return {
+    key,
+    model: delegateName(model ?? key)
+  };
+}
+__name(parseQuota, "parseQuota");
+var delegateName = /* @__PURE__ */ __name((model) => model.charAt(0).toLowerCase() + model.slice(1), "delegateName");
+function assertEnoughQuotas(quotas) {
+  const minimum = minimumQuotasPerPlan();
+  if (quotas.length >= minimum) return;
+  throw new Error(`init needs at least ${minimum} --quota=<key>:<Model>. Every plan in config/saas.yaml must declare one, and the platform refuses a catalogue without it \u2014 so a project generated without one cannot boot. Name what your app counts, for example --quota=notes:Note; the generated provider is where you say how to count it.`);
+}
+__name(assertEnoughQuotas, "assertEnoughQuotas");
+function pascalCase(value) {
+  return value.split(/[^A-Za-z0-9]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+__name(pascalCase, "pascalCase");
+var quotaFileName = /* @__PURE__ */ __name((key) => `${key.replace(/[^A-Za-z0-9]+/g, "-").toLowerCase()}-quota.provider.ts`, "quotaFileName");
+function planInit(options) {
+  const projectKey = options.projectKey;
+  if (!projectKey) throw new Error("init needs a --project-key.");
+  assertValidProjectKey(projectKey);
+  const appLabel = options.appName ?? pascalCase(projectKey);
+  const appName = pascalCase(appLabel);
+  const apiBase = options.apiBase ?? "/api/v1/admin";
+  const quotas = (options.quotas ?? []).map(parseQuota);
+  assertEnoughQuotas(quotas);
+  const hasherClass = options.skipHasher ? null : `${appName}PasswordHasher`;
+  const featureKey = `${projectKey.replace(/[^A-Za-z0-9]+/g, "_").toUpperCase()}_CORE`;
+  const shared = {
+    PROJECT_KEY: projectKey,
+    APP_NAME: appName,
+    APP_LABEL: appLabel,
+    API_BASE: apiBase,
+    FEATURE_KEY: featureKey,
+    REGISTRY_CONST: `${constantCase(projectKey)}_FEATURE_UI_REGISTRY`,
+    MANIFEST_CONST: `${constantCase(projectKey)}_MANIFEST_CONTRIBUTION`,
+    ADMIN_MODULE_CLASS: `${appName}AdminModule`,
+    HASHER_CLASS: hasherClass ?? "",
+    HASHER_FILE: hasherClass ? `${kebabCase(appName)}-password.hasher` : "",
+    STARTER_QUOTAS: renderQuotaBlock(quotas, 25),
+    PRO_QUOTAS: renderQuotaBlock(quotas, 1e3)
+  };
+  const files = [
+    {
+      path: "config/saas.yaml",
+      template: "config/saas.yaml",
+      tokens: {}
+    },
+    {
+      path: "src/saas/feature-ui-registry.ts",
+      template: "src/saas/feature-ui-registry.ts",
+      tokens: {}
+    },
+    {
+      path: "src/saas/admin-manifest.contribution.ts",
+      template: "src/saas/admin-manifest.contribution.ts",
+      tokens: {}
+    },
+    {
+      path: `src/saas/${kebabCase(appName)}-admin.module.ts`,
+      template: "src/saas/admin.module.ts",
+      tokens: {}
+    }
+  ];
+  files.push({
+    path: "src/saas/persistence.ts",
+    template: hasherClass ? "src/saas/persistence.ts" : "src/saas/persistence-without-hasher.ts",
+    tokens: {}
+  });
+  if (hasherClass) {
+    files.push({
+      path: `src/auth/${kebabCase(appName)}-password.hasher.ts`,
+      template: "src/auth/password.hasher.ts",
+      tokens: {}
+    });
+  }
+  const quotaProviders = quotas.map((quota) => ({
+    className: `${pascalCase(quota.key)}QuotaProvider`,
+    path: `src/saas/${quotaFileName(quota.key)}`
+  }));
+  for (const quota of quotas) {
+    files.push({
+      path: `src/saas/${quotaFileName(quota.key)}`,
+      template: "src/saas/quota.provider.ts",
+      tokens: {
+        QUOTA_KEY: quota.key,
+        QUOTA_LABEL: `${pascalCase(quota.key)} count`,
+        QUOTA_CLASS: `${pascalCase(quota.key)}QuotaProvider`,
+        QUOTA_MODEL: quota.model
+      }
+    });
+  }
+  return {
+    files,
+    tokens: shared,
+    quotaProviders,
+    hasherClass
+  };
+}
+__name(planInit, "planInit");
+var constantCase = /* @__PURE__ */ __name((value) => value.replace(/[^A-Za-z0-9]+/g, "_").toUpperCase(), "constantCase");
+var kebabCase = /* @__PURE__ */ __name((value) => value.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[^A-Za-z0-9]+/g, "-").toLowerCase(), "kebabCase");
+function renderQuotaBlock(quotas, limit) {
+  if (quotas.length === 0) return " {}";
+  return quotas.map((quota) => `
+          ${quota.key}: ${limit}`).join("");
+}
+__name(renderQuotaBlock, "renderQuotaBlock");
+function applyTokens(content, tokens) {
+  return content.replace(/__([A-Z_]+)__/g, (full, key) => tokens[key] === void 0 ? full : tokens[key]);
+}
+__name(applyTokens, "applyTokens");
+function patchOptionsFor(plan) {
+  const generates = /* @__PURE__ */ __name((path) => plan.files.some((file) => file.path === path), "generates");
+  return {
+    persistenceImport: generates("src/saas/persistence.ts") ? "./saas/persistence" : null,
+    adminModule: {
+      className: plan.tokens.ADMIN_MODULE_CLASS,
+      importPath: `./saas/${kebabCase(plan.tokens.APP_NAME)}-admin.module`
+    },
+    // Read off the plan, not re-derived: the file it wrote is the file the
+    // import has to name.
+    quotaProviders: plan.quotaProviders.map(({ className, path }) => ({
+      className,
+      importPath: `./${path.replace(/^src\//, "").replace(/\.ts$/, "")}`
+    })),
+    registry: {
+      constName: plan.tokens.REGISTRY_CONST,
+      importPath: "./saas/feature-ui-registry"
+    }
+  };
+}
+__name(patchOptionsFor, "patchOptionsFor");
+
+// src/codemods/v1-imports.ts
+var PUBLIC_PREFIXES = [
+  "ui/",
+  "layouts/",
+  "auth/",
+  "pages/"
+];
+function buildImportMap(table) {
+  const map = /* @__PURE__ */ new Map();
+  for (const [from, to] of Object.entries(table.moves)) {
+    const onSurface = PUBLIC_PREFIXES.some((prefix) => to.startsWith(prefix));
+    if (!onSurface && !to.startsWith("@")) continue;
+    if (from.startsWith("components/")) {
+      map.set(from, to);
+      continue;
+    }
+    if (!from.startsWith("pages-standard/")) continue;
+    const file = from.slice("pages-standard/".length);
+    if (file.includes("/")) continue;
+    map.set(from, to);
+    map.set(`pages/${file}`, to);
+  }
+  for (const [from, to] of Object.entries(table.packages ?? {})) {
+    if (from === "_") continue;
+    map.set(from, to);
+  }
+  for (const [from, to] of Object.entries(table.moveDirectories ?? {})) {
+    map.set(`${from}/`, `${to}/`);
+  }
+  return map;
+}
+__name(buildImportMap, "buildImportMap");
+function wentPrivate(map, subpath) {
+  for (const [prefix, target] of map) {
+    if (prefix.endsWith("/") && target.startsWith("internal/") && subpath.startsWith(prefix)) {
+      return true;
+    }
+  }
+  return false;
+}
+__name(wentPrivate, "wentPrivate");
+function rewriteSubpath(map, subpath) {
+  const direct = map.get(subpath);
+  if (direct !== void 0 && direct !== subpath) return direct;
+  for (const [prefix, target] of map) {
+    if (prefix.endsWith("/") && target.startsWith("@") && subpath.startsWith(prefix)) {
+      return `${target}${subpath.slice(prefix.length)}`;
+    }
+  }
+  if (subpath.startsWith("pages-standard/") && !wentPrivate(map, subpath)) {
+    const file = subpath.slice("pages-standard/".length);
+    if (!file.includes("/")) return `pages/${file}`;
+  }
+  return null;
+}
+__name(rewriteSubpath, "rewriteSubpath");
+function isNoLongerPublic(map, subpath) {
+  if (subpath.startsWith("components/")) return !map.has(subpath);
+  return subpath.startsWith("pages-standard/") && wentPrivate(map, subpath);
+}
+__name(isNoLongerPublic, "isNoLongerPublic");
+var UI_VUE_SPECIFIER = /@saasicat\/ui-vue\/([A-Za-z0-9/_.-]+)/g;
+function rewriteImports(text, map) {
+  const unmapped = /* @__PURE__ */ new Map();
+  let rewritten = 0;
+  const next = text.replace(UI_VUE_SPECIFIER, (whole, subpath) => {
+    const to = rewriteSubpath(map, subpath);
+    if (to === null) {
+      if (isNoLongerPublic(map, subpath)) {
+        unmapped.set(subpath, (unmapped.get(subpath) ?? 0) + 1);
+      }
+      return whole;
+    }
+    rewritten += 1;
+    return to.startsWith("@") ? to : `@saasicat/ui-vue/${to}`;
+  });
+  return {
+    text: next,
+    rewritten,
+    unmapped
+  };
+}
+__name(rewriteImports, "rewriteImports");
+
+// src/codemods/v1-rename.ts
+var escape = /* @__PURE__ */ __name((s) => s.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&"), "escape");
+var FROM_SPECIFIER = /from\s*(['"])([^'"]+)\1/g;
+var isSpace = /* @__PURE__ */ __name((ch) => ch === " " || ch === "	" || ch === "\n" || ch === "\r", "isSpace");
+function namedImports(text) {
+  const found = [];
+  for (const match of text.matchAll(FROM_SPECIFIER)) {
+    let i = (match.index ?? 0) - 1;
+    while (i >= 0 && isSpace(text[i])) i -= 1;
+    if (text[i] !== "}") continue;
+    const close = i;
+    const open = text.lastIndexOf("{", close);
+    if (open < 0) continue;
+    i = open - 1;
+    while (i >= 0 && isSpace(text[i])) i -= 1;
+    let head = text.slice(Math.max(0, i - 3), i + 1);
+    if (head === "type") {
+      i -= 4;
+      while (i >= 0 && isSpace(text[i])) i -= 1;
+      head = text.slice(Math.max(0, i - 5), i + 1);
+    } else {
+      head = text.slice(Math.max(0, i - 5), i + 1);
+    }
+    if (head !== "import") continue;
+    const names = text.slice(open + 1, close).split(",").map((raw) => {
+      const words = raw.trim().split(/\s+/);
+      if (words[0] === "type") words.shift();
+      return words[0] ?? "";
+    }).filter((name) => name.length > 0);
+    found.push({
+      names,
+      specifier: match[2]
+    });
+  }
+  return found;
+}
+__name(namedImports, "namedImports");
+function rewriteNames(text, table) {
+  let next = text;
+  let rewritten = 0;
+  const ambiguous = /* @__PURE__ */ new Set();
+  const perEntry = /* @__PURE__ */ new Map();
+  for (const { names, specifier } of namedImports(text)) {
+    const mapping = table.entryTokens[specifier];
+    for (const name of names) {
+      const knownSomewhere = Object.values(table.entryTokens).some((m) => name in m);
+      if (!knownSomewhere) continue;
+      const already = perEntry.get(name);
+      if (mapping && name in mapping && (already === void 0 || already === mapping[name])) {
+        perEntry.set(name, mapping[name]);
+      } else {
+        if (already !== void 0) perEntry.delete(name);
+        ambiguous.add(`${name} from '${specifier}'`);
+      }
+    }
+  }
+  for (const [from, to] of perEntry) {
+    next = next.replace(new RegExp(`\\b${escape(from)}\\b`, "g"), () => {
+      rewritten += 1;
+      return to;
+    });
+  }
+  for (const [from, to] of Object.entries(table.identifierStems)) {
+    next = next.replace(new RegExp(escape(from), "g"), () => {
+      rewritten += 1;
+      return to;
+    });
+  }
+  for (const [from, to] of Object.entries(table.registryKeys)) {
+    const symbolFor = new RegExp(`(Symbol\\.for\\(\\s*['"\`])${escape(from)}`, "g");
+    next = next.replace(symbolFor, (_, head) => {
+      rewritten += 1;
+      return `${head}${to}`;
+    });
+    if (from.startsWith("@")) continue;
+    const literal = new RegExp(`(['"\`])${escape(from)}`, "g");
+    next = next.replace(literal, (_, quote) => {
+      rewritten += 1;
+      return `${quote}${to}`;
+    });
+  }
+  for (const [from, to] of Object.entries(table.subpaths)) {
+    next = next.replace(new RegExp(escape(from), "g"), () => {
+      rewritten += 1;
+      return to;
+    });
+  }
+  return {
+    text: next,
+    rewritten,
+    ambiguous: [
+      ...ambiguous
+    ].sort()
+  };
+}
+__name(rewriteNames, "rewriteNames");
+
+// src/init/patch-app-module.ts
+var MARKER = "SaaSiCatModule.forRoot";
+function patchAppModule(source, options) {
+  const block = renderForRootBlock(options);
+  const manualBlock = `${renderImports(options)}
+
+${block}`;
+  if (source.includes(MARKER)) {
+    return {
+      source,
+      status: "already-wired",
+      reason: "",
+      manualBlock: ""
+    };
+  }
+  const importsArray = findImportsArray(source);
+  if (!importsArray) {
+    return {
+      source,
+      status: "declined",
+      reason: "no `@Module({ imports: [ ... ] })` was found in this file, so there is nowhere to add the platform without guessing at the structure",
+      manualBlock
+    };
+  }
+  const withImports = addImportStatements(source, options);
+  const target = findImportsArray(withImports);
+  const indent = " ".repeat(target.indent + 4);
+  const entries = `${block},
+${options.adminModule.className},`;
+  const wasEmpty = /^\s*\]/.test(withImports.slice(target.openBracket + 1));
+  const trailing = wasEmpty ? " ".repeat(target.indent) : indent;
+  const inserted = `
+${indent}${entries.split("\n").join(`
+${indent}`)}
+${trailing}`;
+  return {
+    source: withImports.slice(0, target.openBracket + 1) + inserted + withImports.slice(target.openBracket + 1),
+    status: "patched",
+    reason: "",
+    manualBlock: ""
+  };
+}
+__name(patchAppModule, "patchAppModule");
+function findImportsArray(source) {
+  const decorator = source.indexOf("@Module(");
+  if (decorator === -1) return null;
+  const match = /(^|\n)([ \t]*)imports\s*:\s*\[/.exec(source.slice(decorator));
+  if (!match) return null;
+  const openBracket = decorator + match.index + match[0].length - 1;
+  return {
+    openBracket,
+    indent: match[2].length
+  };
+}
+__name(findImportsArray, "findImportsArray");
+function renderImports(options) {
+  const lines = [
+    "import { loadPlanCatalogFromFile } from '@saasicat/nest/billing';",
+    "import { SaaSiCatModule, defineSaaSiCat } from '@saasicat/nest/platform';",
+    `import { ${options.registry.constName} } from '${options.registry.importPath}';`,
+    `import { ${options.adminModule.className} } from '${options.adminModule.importPath}';`
+  ];
+  if (options.persistenceImport) {
+    lines.push(`import { persistence } from '${options.persistenceImport}';`);
+  }
+  for (const quota of options.quotaProviders) {
+    lines.push(`import { ${quota.className} } from '${quota.importPath}';`);
+  }
+  return lines.join("\n");
+}
+__name(renderImports, "renderImports");
+function addImportStatements(source, options) {
+  const lines = source.split("\n");
+  const block = renderImports(options).split("\n");
+  lines.splice(endOfLastImport(lines) + 1, 0, ...block);
+  return lines.join("\n");
+}
+__name(addImportStatements, "addImportStatements");
+function endOfLastImport(lines) {
+  let end = -1;
+  let open = false;
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (!open && !/^\s*import\s/.test(line)) continue;
+    open = true;
+    if (/\bfrom\s+['"][^'"]+['"]/.test(line) || /^\s*import\s+['"][^'"]+['"]/.test(line)) {
+      end = index;
+      open = false;
+    }
+  }
+  return end;
+}
+__name(endOfLastImport, "endOfLastImport");
+function renderForRootBlock(options) {
+  const quotaList = options.quotaProviders.map((q) => q.className).join(", ");
+  return [
+    "SaaSiCatModule.forRoot(",
+    "    defineSaaSiCat({",
+    "        // Plans straight from the YAML. Apps that manage plans in the",
+    "        // SuperAdmin UI pass `dbCatalog` instead.",
+    "        planCatalog: loadPlanCatalogFromFile({ path: 'config/saas.yaml' }),",
+    "        // Your authentication guard. This does NOT compile until you",
+    "        // name one, and that is deliberate: an empty array is how the",
+    "        // platform is told an endpoint should be auth-free, so a",
+    "        // placeholder `[]` here would publish GET /admin/discovery \u2014",
+    "        // your whole capability inventory \u2014 and the manifest routes to",
+    "        // anyone who asks. Import your guard and put it in.",
+    "        controller: { guards: [YourAuthGuard] },",
+    options.persistenceImport ? "        persistence," : "        // persistence: prismaPersistence({ client: PrismaService }),",
+    "        catalog: { featureUiRegistry: " + options.registry.constName + " },",
+    "        adminResources: true,",
+    "        promoCodes: true,",
+    quotaList ? `        quotaProviders: [${quotaList}],` : "        quotaProviders: [],",
+    "    }),",
+    ")"
+  ].join("\n");
+}
+__name(renderForRootBlock, "renderForRootBlock");
+var LIMIT_FILTER_PROVIDER = "{ provide: APP_FILTER, useClass: LimitExceededFilter }";
+var LIMIT_FILTER_IMPORTS = [
+  "import { APP_FILTER } from '@nestjs/core';",
+  "import { LimitExceededFilter } from '@saasicat/nest/billing';"
+].join("\n");
+
+// src/cli-context.module.ts
 import { Module } from "@nestjs/common";
 import { asProvider } from "@saasicat/nest";
 function _ts_decorate8(decorators, target, key, desc) {
@@ -2411,6 +3082,7 @@ export {
   AuditTailCommand,
   AuditTailFlow,
   CLI_CONTEXT_CONFIG_TOKEN,
+  CONSTRAINTS_MARKER,
   CliContextModule,
   CliContextService,
   CliError,
@@ -2421,6 +3093,8 @@ export {
   DiscoverySnapshotDoctorCheck,
   DoctorCommands,
   DoctorFlow,
+  LIMIT_FILTER_IMPORTS,
+  LIMIT_FILTER_PROVIDER,
   MANIFEST_ACCESS_PORT_TOKEN,
   MANIFEST_CHECKS_TOKEN,
   ManifestCheckCommand,
@@ -2432,24 +3106,56 @@ export {
   MfaSetupFlow,
   PLATFORM_DOCTOR_CHECK_PROVIDERS,
   PlanCatalogDoctorCheck,
+  UI_VUE_SPECIFIER,
   USER_MANAGEMENT_PORT_TOKEN,
   USER_PORT_TOKEN,
   UserCommands,
   UserPortDoctorCheck,
   WhoAmIFlow,
+  appendConstraints,
   applyFragmentBlocks,
+  applyTokens,
+  assertModelsExist,
+  assertValidProjectKey,
+  assertValidQuotaKey,
   blankStringLiterals,
   blockBodyLines,
   breaksContract,
+  buildImportMap,
   checkSchema,
+  constraintsFor,
+  enableFkPointers,
   extractBlockNames,
   extractBlocks,
   extractModelBlocks,
   extractModelNames,
+  findFkPointers,
+  foreignKeyOf,
+  hasBackRelation,
+  hasConstraints,
+  isNoLongerPublic,
+  isOneToOne,
+  kebabCase,
+  migrationCreatedBy,
+  minimumQuotasPerPlan,
+  namedImports,
   parseBlockAttributes,
   parseEnumValues,
   parseFields,
+  parseQuota,
   parseSchema,
+  pascalCase,
+  patchAppModule,
+  patchOptionsFor,
+  planInit,
+  projectKeyPattern,
+  quotaKeyPattern,
+  relationNameOf,
+  reportConstraints,
+  rewriteImports,
+  rewriteNames,
+  rewriteSubpath,
   stripLineComment,
-  structuralOnly
+  structuralOnly,
+  tablesAddressedBy
 };