@prisma/orm-mongo 8.0.0-rc.5 → 8.0.0-rc.5-dev.2

package/skills/prisma-8/upgrading/app/upgrades/0.11-to-0.12/re-emit-closed-mongo-contracts.ts

@@ -0,0 +1,202 @@
+/**
+ * Re-emits every Mongo contract in the consumer project so emitted
+ * `contract.json` / `contract.d.ts` pick up closed `$jsonSchema`
+ * validators (`additionalProperties: false` at every level, including
+ * polymorphic `oneOf` branches).
+ *
+ * Background: starting at the 0.12 release, MongoDB emits closed
+ * `$jsonSchema` validators by default. The contract canonicalizer also
+ * preserves `additionalProperties` through emission, so re-emitting is
+ * the consumer-facing migration for on-disk contract artefacts. A
+ * non-variant Mongo model must resolve to an `objectId` `_id`; otherwise
+ * interpret fails with `PSL_MONGO_ID_REQUIRED` — fix the PSL/TS source
+ * before re-emitting.
+ *
+ * After re-emitting, apply the resulting open→closed validator migration
+ * with `prisma-next db update -y` (or `pnpm db:update -y` if your
+ * project wraps it). The planner classifies the validator tightening as
+ * `destructive`; without `-y` the apply step refuses to run.
+ *
+ * Dispatch: walks the project root for directories that contain both
+ * `prisma.config.ts` and a committed `contract.json` whose storage
+ * tree includes `"kind": "mongo-database"`. In each match, runs
+ * `pnpm emit` when a `package.json` scripts.emit entry exists, otherwise
+ * `pnpm exec prisma-next contract emit`.
+ *
+ * Flags:
+ *   --check   dry-run; lists directories that would be re-emitted and
+ *             exits 1 if any contract.json still lacks closed validators.
+ */
+import { execFile } from 'node:child_process';
+import { access, readdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+
+const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build']);
+
+const dryRun = process.argv.includes('--check');
+const projectRoot = process.cwd();
+
+async function pathExists(path: string): Promise<boolean> {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function findPrismaNextConfigDirs(root: string): Promise<string[]> {
+  const out: string[] = [];
+
+  async function walk(dir: string): Promise<void> {
+    let entries: Awaited<ReturnType<typeof readdir>>;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS.has(entry.name)) continue;
+        await walk(join(dir, entry.name));
+      } else if (entry.isFile() && entry.name === 'prisma.config.ts') {
+        out.push(dir);
+      }
+    }
+  }
+
+  await walk(root);
+  return out.sort();
+}
+
+function contractJsonCandidates(configDir: string): string[] {
+  return [
+    join(configDir, 'src', 'contract.json'),
+    join(configDir, 'src', 'prisma', 'contract.json'),
+    join(configDir, 'prisma', 'contract.json'),
+    join(configDir, 'contract.json'),
+  ];
+}
+
+async function resolveContractJson(configDir: string): Promise<string | null> {
+  for (const candidate of contractJsonCandidates(configDir)) {
+    if (await pathExists(candidate)) return candidate;
+  }
+  return null;
+}
+
+async function isMongoContract(contractPath: string): Promise<boolean> {
+  const raw = await readFile(contractPath, 'utf-8');
+  return raw.includes('"kind": "mongo-database"') || raw.includes('"kind":"mongo-database"');
+}
+
+/**
+ * A contract is in the closed-validator (post-0.12) format when every object
+ * schema that declares a `properties` map also carries `additionalProperties:
+ * false`. That covers collection validators, nested value objects, and each
+ * polymorphic `oneOf` branch — all of which expose `properties`.
+ *
+ * The one exception is a polymorphic schema's top-level node: it carries both
+ * base `properties` and a `oneOf`, and is deliberately left open because
+ * closure is enforced on each branch (a document must match exactly one closed
+ * branch). Such a node is exempt from the `additionalProperties: false`
+ * requirement, but its branches are still walked and checked.
+ *
+ * A substring scan is unsafe here: a single closed branch would mask a sibling
+ * that still needs re-emitting.
+ */
+/** Narrows an arbitrary JSON-parsed value to a plain object (non-null, non-array). */
+function isJsonObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function contractLooksClosed(raw: string): boolean {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return false;
+  }
+
+  function isClosed(node: unknown): boolean {
+    if (Array.isArray(node)) return node.every(isClosed);
+    if (!isJsonObject(node)) return true;
+
+    const hasProperties = isJsonObject(node['properties']);
+    const isPolymorphicTopLevel = Array.isArray(node['oneOf']);
+    if (hasProperties && !isPolymorphicTopLevel && node['additionalProperties'] !== false) {
+      return false;
+    }
+
+    return Object.values(node).every(isClosed);
+  }
+
+  return isClosed(parsed);
+}
+
+async function packageJsonHasEmitScript(configDir: string): Promise<boolean> {
+  const pkgPath = join(configDir, 'package.json');
+  if (!(await pathExists(pkgPath))) return false;
+  const raw = await readFile(pkgPath, 'utf-8');
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    if (!isJsonObject(parsed)) return false;
+    const scripts = parsed['scripts'];
+    if (!isJsonObject(scripts)) return false;
+    return typeof scripts['emit'] === 'string' && scripts['emit'].length > 0;
+  } catch {
+    return false;
+  }
+}
+
+async function runEmit(configDir: string): Promise<void> {
+  const hasEmitScript = await packageJsonHasEmitScript(configDir);
+  const cmd = hasEmitScript ? 'pnpm' : 'pnpm';
+  const args = hasEmitScript ? ['emit'] : ['exec', 'prisma-next', 'contract', 'emit'];
+  await execFileAsync(cmd, args, { cwd: configDir, env: process.env });
+}
+
+const configDirs = await findPrismaNextConfigDirs(projectRoot);
+const mongoDirs: Array<{ dir: string; contractPath: string }> = [];
+
+for (const dir of configDirs) {
+  const contractPath = await resolveContractJson(dir);
+  if (contractPath === null) continue;
+  if (!(await isMongoContract(contractPath))) continue;
+  mongoDirs.push({ dir, contractPath });
+}
+
+if (mongoDirs.length === 0) {
+  console.error(`No Mongo contract directories found under ${projectRoot}.`);
+  process.exit(1);
+}
+
+let needsFix = 0;
+let alreadyClean = 0;
+
+for (const { dir, contractPath } of mongoDirs) {
+  const rel = dir.slice(projectRoot.length + 1) || '.';
+  const raw = await readFile(contractPath, 'utf-8');
+  if (contractLooksClosed(raw)) {
+    alreadyClean += 1;
+    console.log(`OK    ${rel}`);
+    continue;
+  }
+  needsFix += 1;
+  if (dryRun) {
+    console.log(`WOULD RE-EMIT  ${rel}`);
+    continue;
+  }
+  console.log(`EMIT  ${rel}`);
+  await runEmit(dir);
+}
+
+console.log();
+console.log(
+  `${mongoDirs.length} Mongo contract(s): ${needsFix} ${dryRun ? 'needing re-emit' : 're-emitted'}, ${alreadyClean} already closed.`,
+);
+
+if (dryRun && needsFix > 0) process.exit(1);

package/skills/prisma-8/upgrading/app/upgrades/0.11-to-0.12/re-emit-domain-namespaced-contracts.ts

@@ -0,0 +1,201 @@
+/**
+ * Re-emits every contract artefact still on the pre-0.12 flat domain plane
+ * (`contract.models` / `contract.valueObjects` at the contract root) so
+ * emitted JSON and `contract.d.ts` pick up `contract.domain.namespaces.<ns>`.
+ *
+ * Background: starting at 0.12 (symmetric domain plane, ADR 221), models
+ * and value objects live under `domain.namespaces`. The supported read
+ * paths are `contract.domain.namespaces` plus helpers such as
+ * `contractModels()` / `ContractModelsMap`.
+ *
+ * Dispatch: walks the project root for `prisma.config.ts` directories,
+ * resolves each space's committed `contract.json` / `contract.d.ts`, and
+ * re-emits when the flat domain shape remains. Uses the nearest ancestor
+ * `package.json` `scripts.emit` when present; otherwise runs
+ * `prisma-next contract emit --config <path>`.
+ *
+ * Flags:
+ *   --check   dry-run; lists contract-spaces that still need re-emitting
+ *             and exits 1 if any remain.
+ */
+import { execFile } from 'node:child_process';
+import { access, readdir, readFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+
+const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build']);
+
+const dryRun = process.argv.includes('--check');
+const projectRoot = process.cwd();
+
+async function pathExists(path: string): Promise<boolean> {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function isJsonObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+async function findPrismaNextConfigDirs(root: string): Promise<string[]> {
+  const out: string[] = [];
+
+  async function walk(dir: string): Promise<void> {
+    let entries: Awaited<ReturnType<typeof readdir>>;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS.has(entry.name)) continue;
+        await walk(join(dir, entry.name));
+      } else if (entry.isFile() && entry.name === 'prisma.config.ts') {
+        out.push(dir);
+      }
+    }
+  }
+
+  await walk(root);
+  return out.sort();
+}
+
+function contractJsonCandidates(configDir: string): string[] {
+  return [
+    join(configDir, 'src', 'contract.json'),
+    join(configDir, 'src', 'prisma', 'contract.json'),
+    join(configDir, 'prisma', 'contract.json'),
+    join(configDir, 'contract.json'),
+  ];
+}
+
+function contractDtsCandidates(configDir: string): string[] {
+  return [
+    join(configDir, 'src', 'contract.d.ts'),
+    join(configDir, 'src', 'prisma', 'contract.d.ts'),
+    join(configDir, 'prisma', 'contract.d.ts'),
+    join(configDir, 'contract.d.ts'),
+  ];
+}
+
+function contractJsonNeedsDomainPlaneMigration(raw: string): boolean {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return false;
+  }
+  if (!isJsonObject(parsed)) return false;
+  const domain = parsed['domain'];
+  if (!isJsonObject(domain)) return true;
+  const namespaces = domain['namespaces'];
+  return !isJsonObject(namespaces) || Object.keys(namespaces).length === 0;
+}
+
+function contractDtsNeedsDomainPlaneMigration(raw: string): boolean {
+  return raw.includes("Contract['models']");
+}
+
+async function packageJsonHasEmitScript(dir: string): Promise<boolean> {
+  const pkgPath = join(dir, 'package.json');
+  if (!(await pathExists(pkgPath))) return false;
+  const raw = await readFile(pkgPath, 'utf-8');
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    if (!isJsonObject(parsed)) return false;
+    const scripts = parsed['scripts'];
+    if (!isJsonObject(scripts)) return false;
+    return typeof scripts['emit'] === 'string' && scripts['emit'].length > 0;
+  } catch {
+    return false;
+  }
+}
+
+async function resolveEmitInvocation(configDir: string): Promise<{
+  readonly cwd: string;
+  readonly args: string[];
+  readonly key: string;
+}> {
+  let dir = configDir;
+  while (dir.startsWith(projectRoot)) {
+    if (await packageJsonHasEmitScript(dir)) {
+      return { cwd: dir, args: ['emit'], key: `script:${dir}` };
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  const configPath = join(configDir, 'prisma.config.ts');
+  return {
+    cwd: projectRoot,
+    args: ['exec', 'prisma-next', 'contract', 'emit', '--config', configPath],
+    key: `config:${configPath}`,
+  };
+}
+
+async function runEmit(configDir: string): Promise<void> {
+  const { cwd, args } = await resolveEmitInvocation(configDir);
+  await execFileAsync('pnpm', args, { cwd, env: process.env });
+}
+
+async function configDirNeedsDomainPlaneMigration(configDir: string): Promise<boolean> {
+  for (const candidate of contractJsonCandidates(configDir)) {
+    if (!(await pathExists(candidate))) continue;
+    const raw = await readFile(candidate, 'utf-8');
+    if (contractJsonNeedsDomainPlaneMigration(raw)) return true;
+  }
+  for (const candidate of contractDtsCandidates(configDir)) {
+    if (!(await pathExists(candidate))) continue;
+    const raw = await readFile(candidate, 'utf-8');
+    if (contractDtsNeedsDomainPlaneMigration(raw)) return true;
+  }
+  return false;
+}
+
+const configDirs = await findPrismaNextConfigDirs(projectRoot);
+const emitKeys = new Set<string>();
+const targets: string[] = [];
+
+for (const configDir of configDirs) {
+  if (!(await configDirNeedsDomainPlaneMigration(configDir))) continue;
+  const { key } = await resolveEmitInvocation(configDir);
+  if (emitKeys.has(key)) continue;
+  emitKeys.add(key);
+  targets.push(configDir);
+}
+
+if (targets.length === 0) {
+  console.error(`No flat-domain contract candidates under ${projectRoot}.`);
+  process.exit(dryRun ? 0 : 1);
+}
+
+let needsFix = 0;
+
+for (const configDir of targets) {
+  const rel = configDir.slice(projectRoot.length + 1) || '.';
+  if (!(await configDirNeedsDomainPlaneMigration(configDir))) {
+    console.log(`OK    ${rel}`);
+    continue;
+  }
+  needsFix += 1;
+  if (dryRun) {
+    console.log(`WOULD RE-EMIT  ${rel}`);
+    continue;
+  }
+  console.log(`EMIT  ${rel}`);
+  await runEmit(configDir);
+}
+
+console.log();
+console.log(
+  `${targets.length} contract-space(s): ${needsFix} ${dryRun ? 'needing re-emit' : 're-emitted'}.`,
+);
+
+if (dryRun && needsFix > 0) process.exit(1);

package/skills/prisma-8/upgrading/app/upgrades/0.11-to-0.12/re-emit-postgres-public-default.ts

@@ -0,0 +1,198 @@
+/**
+ * Re-emits every Postgres contract whose default namespace still uses the
+ * pre-0.12 `__unbound__` / `postgres-unbound-schema` sentinel so emitted
+ * `contract.json` / `contract.d.ts` pick up the `public` / `postgres-schema`
+ * default (public-by-default).
+ *
+ * Starting at 0.12, un-namespaced Postgres models resolve to the `public`
+ * namespace id. Explicit `namespace unbound { … }` in PSL still round-trips
+ * to `__unbound__`; this script targets only contracts whose *default*
+ * namespace is still the old sentinel shape.
+ *
+ * Dispatch: walks the project root for `prisma.config.ts` directories,
+ * resolves each space's committed `contract.json`, and re-emits when the
+ * storage tree still includes `"kind": "postgres-unbound-schema"`. Uses
+ * the nearest ancestor `package.json` `scripts.emit` when present; otherwise
+ * runs `prisma-next contract emit --config <path>`.
+ *
+ * Flags:
+ *   --check   dry-run; lists contract-spaces that still need re-emitting and
+ *             exits 1 if any remain.
+ */
+import { execFile } from 'node:child_process';
+import { access, readdir, readFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+
+const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build']);
+
+const dryRun = process.argv.includes('--check');
+const projectRoot = process.cwd();
+
+async function pathExists(path: string): Promise<boolean> {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function isJsonObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+async function findPrismaNextConfigDirs(root: string): Promise<string[]> {
+  const out: string[] = [];
+
+  async function walk(dir: string): Promise<void> {
+    let entries: Awaited<ReturnType<typeof readdir>>;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS.has(entry.name)) continue;
+        await walk(join(dir, entry.name));
+      } else if (entry.isFile() && entry.name === 'prisma.config.ts') {
+        out.push(dir);
+      }
+    }
+  }
+
+  await walk(root);
+  return out.sort();
+}
+
+function contractJsonCandidates(configDir: string): string[] {
+  return [
+    join(configDir, 'src', 'contract.json'),
+    join(configDir, 'src', 'prisma', 'contract.json'),
+    join(configDir, 'prisma', 'contract.json'),
+    join(configDir, 'contract.json'),
+  ];
+}
+
+async function resolveContractJson(configDir: string): Promise<string | null> {
+  for (const candidate of contractJsonCandidates(configDir)) {
+    if (await pathExists(candidate)) return candidate;
+  }
+  return null;
+}
+
+function contractNeedsPublicDefaultMigration(raw: string): boolean {
+  return (
+    raw.includes('"kind": "postgres-unbound-schema"') ||
+    raw.includes('"kind":"postgres-unbound-schema"')
+  );
+}
+
+async function packageJsonHasEmitScript(dir: string): Promise<boolean> {
+  const pkgPath = join(dir, 'package.json');
+  if (!(await pathExists(pkgPath))) return false;
+  const raw = await readFile(pkgPath, 'utf-8');
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    if (!isJsonObject(parsed)) return false;
+    const scripts = parsed['scripts'];
+    if (!isJsonObject(scripts)) return false;
+    return typeof scripts['emit'] === 'string' && scripts['emit'].length > 0;
+  } catch {
+    return false;
+  }
+}
+
+async function packageJsonHasBuildContractSpaceScript(dir: string): Promise<boolean> {
+  const pkgPath = join(dir, 'package.json');
+  if (!(await pathExists(pkgPath))) return false;
+  const raw = await readFile(pkgPath, 'utf-8');
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    if (!isJsonObject(parsed)) return false;
+    const scripts = parsed['scripts'];
+    if (!isJsonObject(scripts)) return false;
+    return (
+      typeof scripts['build:contract-space'] === 'string' &&
+      scripts['build:contract-space'].length > 0
+    );
+  } catch {
+    return false;
+  }
+}
+
+async function resolveEmitInvocation(configDir: string): Promise<{
+  readonly cwd: string;
+  readonly args: string[];
+  readonly key: string;
+}> {
+  let dir = configDir;
+  while (dir.startsWith(projectRoot)) {
+    if (await packageJsonHasEmitScript(dir)) {
+      return { cwd: dir, args: ['emit'], key: `script:${dir}` };
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  const configPath = join(configDir, 'prisma.config.ts');
+  return {
+    cwd: projectRoot,
+    args: ['exec', 'prisma-next', 'contract', 'emit', '--config', configPath],
+    key: `config:${configPath}`,
+  };
+}
+
+async function runEmit(configDir: string): Promise<void> {
+  const { cwd, args } = await resolveEmitInvocation(configDir);
+  await execFileAsync('pnpm', args, { cwd, env: process.env });
+}
+
+const configDirs = await findPrismaNextConfigDirs(projectRoot);
+const emitKeys = new Set<string>();
+const targets: Array<{ configDir: string; contractPath: string }> = [];
+
+for (const configDir of configDirs) {
+  if (await packageJsonHasBuildContractSpaceScript(configDir)) continue;
+  const contractPath = await resolveContractJson(configDir);
+  if (contractPath === null) continue;
+  const raw = await readFile(contractPath, 'utf-8');
+  if (!contractNeedsPublicDefaultMigration(raw)) continue;
+  const { key } = await resolveEmitInvocation(configDir);
+  if (emitKeys.has(key)) continue;
+  emitKeys.add(key);
+  targets.push({ configDir, contractPath });
+}
+
+if (targets.length === 0) {
+  console.error(`No Postgres public-default migration candidates under ${projectRoot}.`);
+  process.exit(dryRun ? 0 : 1);
+}
+
+let needsFix = 0;
+
+for (const { configDir, contractPath } of targets) {
+  const rel = configDir.slice(projectRoot.length + 1) || '.';
+  const raw = await readFile(contractPath, 'utf-8');
+  if (!contractNeedsPublicDefaultMigration(raw)) {
+    console.log(`OK    ${rel}`);
+    continue;
+  }
+  needsFix += 1;
+  if (dryRun) {
+    console.log(`WOULD RE-EMIT  ${rel}`);
+    continue;
+  }
+  console.log(`EMIT  ${rel}`);
+  await runEmit(configDir);
+}
+
+console.log();
+console.log(
+  `${targets.length} contract-space(s): ${needsFix} ${dryRun ? 'needing re-emit' : 're-emitted'}.`,
+);
+
+if (dryRun && needsFix > 0) process.exit(1);