@prisma-next/cli 0.5.1 → 0.6.0-dev.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma-next/cli",
-  "version": "0.5.1",
+  "version": "0.6.0-dev.10",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
@@ -27,27 +27,27 @@
     "string-width": "^8.2.1",
     "strip-ansi": "^7.2.0",
     "wrap-ansi": "^10.0.0",
-    "@prisma-next/config": "0.5.1",
-    "@prisma-next/contract": "0.5.1",
-    "@prisma-next/emitter": "0.5.1",
-    "@prisma-next/errors": "0.5.1",
-    "@prisma-next/framework-components": "0.5.1",
-    "@prisma-next/migration-tools": "0.5.1",
-    "@prisma-next/psl-printer": "0.5.1",
-    "@prisma-next/utils": "0.5.1"
+    "@prisma-next/config": "0.6.0-dev.10",
+    "@prisma-next/contract": "0.6.0-dev.10",
+    "@prisma-next/emitter": "0.6.0-dev.10",
+    "@prisma-next/errors": "0.6.0-dev.10",
+    "@prisma-next/framework-components": "0.6.0-dev.10",
+    "@prisma-next/psl-printer": "0.6.0-dev.10",
+    "@prisma-next/utils": "0.6.0-dev.10",
+    "@prisma-next/migration-tools": "0.6.0-dev.10"
   },
   "devDependencies": {
     "@types/node": "24.10.4",
     "tsdown": "0.22.0",
     "typescript": "5.9.3",
     "vitest": "4.1.5",
-    "@prisma-next/sql-contract": "0.5.1",
-    "@prisma-next/sql-contract-emitter": "0.5.1",
-    "@prisma-next/sql-contract-ts": "0.5.1",
-    "@prisma-next/sql-operations": "0.5.1",
+    "@prisma-next/sql-contract": "0.6.0-dev.10",
+    "@prisma-next/sql-contract-emitter": "0.6.0-dev.10",
+    "@prisma-next/sql-operations": "0.6.0-dev.10",
+    "@prisma-next/sql-contract-ts": "0.6.0-dev.10",
     "@prisma-next/test-utils": "0.0.1",
-    "@prisma-next/sql-runtime": "0.5.1",
     "@prisma-next/tsconfig": "0.0.0",
+    "@prisma-next/sql-runtime": "0.6.0-dev.10",
     "@prisma-next/tsdown": "0.0.0"
   },
   "exports": {

package/src/commands/init/detect-package-manager.ts

@@ -1,15 +1,39 @@
 import { existsSync } from 'node:fs';
-import { detect } from 'package-manager-detector/detect';
+import { detect, getUserAgent } from 'package-manager-detector/detect';
 import { join } from 'pathe';
 
 export type PackageManager = 'pnpm' | 'npm' | 'yarn' | 'bun' | 'deno';
 
 const KNOWN: ReadonlySet<string> = new Set<PackageManager>(['pnpm', 'npm', 'yarn', 'bun', 'deno']);
 
+/**
+ * Resolves the package manager `init` should drive for `add` / `install`
+ * commands. Tries, in order:
+ *
+ *  1. **`detect()`** — walks up from `cwd` looking for a lockfile, the
+ *     `packageManager` field, the `devEngines.packageManager` field, or
+ *     install metadata. This is the right answer whenever the user is
+ *     anywhere inside an existing project, including a deep workspace
+ *     subdirectory.
+ *
+ *  2. **`getUserAgent()`** — parses `npm_config_user_agent`, the env var
+ *     every PM sets when it spawns a script. This catches the
+ *     bare-directory case where there's no project to walk up to but the
+ *     user invoked us via `pnpm dlx prisma-next init` / `bunx
+ *     prisma-next init` / `yarn dlx …`. Same signal used by every
+ *     `create-*` tool in the ecosystem (`create-vite`, `create-next-app`,
+ *     `create-astro`, `@antfu/ni`, …).
+ *
+ *  3. **`npm`** — final fallback. Always present alongside Node.
+ */
 export async function detectPackageManager(cwd: string): Promise<PackageManager> {
-  const result = await detect({ cwd });
-  if (result && KNOWN.has(result.name)) {
-    return result.name as PackageManager;
+  const detected = await detect({ cwd });
+  if (detected && KNOWN.has(detected.name)) {
+    return detected.name as PackageManager;
+  }
+  const userAgent = getUserAgent();
+  if (userAgent !== null && KNOWN.has(userAgent)) {
+    return userAgent as PackageManager;
   }
   return 'npm';
 }

package/src/commands/init/errors.ts

@@ -1,21 +1,5 @@
 import { CliStructuredError } from '../../utils/cli-errors';
 
-/**
- * No `package.json` / `deno.json` / `deno.jsonc` in the target directory.
- *
- * `init` cannot bootstrap a fresh project from a bare directory (NG1) — that
- * gap is tracked separately. The fix is for the user to run `npm init` (or
- * the equivalent for their package manager) first.
- */
-export function errorInitMissingManifest(): CliStructuredError {
-  return new CliStructuredError('5001', 'No project manifest found', {
-    domain: 'CLI',
-    why: 'No package.json or deno.json found in the target directory. `prisma-next init` requires an existing project to attach to.',
-    fix: 'Initialize your project first (e.g. `npm init -y` or `deno init`), then re-run `prisma-next init`.',
-    docsUrl: 'https://prisma-next.dev/docs/cli/init',
-  });
-}
-
 /**
  * Re-init in non-interactive mode without `--force`. Distinct from the
  * decline-the-prompt path (which is `errorInitUserAborted`) because here

package/src/commands/init/exit-codes.ts

@@ -27,9 +27,9 @@ export const INIT_EXIT_INTERNAL_ERROR = 1;
 /**
  * Preconditions not met. The caller asked for something we cannot do
  * without more input or a different environment. Examples:
- *   - missing `package.json` / `deno.json`
  *   - non-interactive mode without enough flags to proceed
  *   - re-init without `--force` in non-interactive mode
+ *   - malformed `package.json` / `tsconfig.json`
  */
 export const INIT_EXIT_PRECONDITION = 2;
 

package/src/commands/init/hygiene-package-scripts.ts

@@ -89,3 +89,80 @@ export function mergePackageScripts(
   const trailingNewline = existing.endsWith('\n') ? '\n' : '';
   return { content: `${JSON.stringify(parsed, null, 2)}${trailingNewline}`, warnings };
 }
+
+export interface EsmModuleTypeResult {
+  /**
+   * The new package.json content. `null` when no change is required —
+   * either `"type": "module"` is already set, or the user has explicitly
+   * opted into a different module type (in which case `warning` is set).
+   */
+  readonly content: string | null;
+  /**
+   * Structured warning raised when `"type"` is already set to a value
+   * other than `"module"`. The user's explicit choice is preserved, but
+   * the scaffolded `db.ts` uses the ESM-only `with { type: 'json' }`
+   * import attribute and will not load under CJS resolution.
+   */
+  readonly warning: string | null;
+}
+
+/**
+ * Idempotently sets `"type": "module"` on a `package.json` so the
+ * scaffolded `prisma/db.ts` — which uses the ESM-only `with { type: 'json' }`
+ * import attribute — loads as ES module under Node's loader (TML-2494).
+ *
+ * Without this field Node either:
+ *
+ * - emits `MODULE_TYPELESS_PACKAGE_JSON` and reparses the file as ESM
+ *   with a perf penalty (Node 22+ with `--experimental-strip-types`), or
+ * - hard-fails with `ERR_*` because the CJS loader cannot parse the
+ *   import-attribute syntax (older Node, or any tool that doesn't
+ *   reparse).
+ *
+ * Behaviour:
+ *
+ * - **Field missing** → set to `"module"`. New entry is inserted right
+ *   after `"name"` (when present) so the diff lands in a conventional
+ *   spot for human review; falls through to the natural append position
+ *   otherwise.
+ * - **Field already `"module"`** → no-op (idempotent).
+ * - **Field set to anything else** (e.g. `"commonjs"`) → leave it alone
+ *   and surface a structured warning. The user explicitly opted out of
+ *   ESM and we don't silently overwrite that.
+ */
+export function ensureEsmModuleType(existing: string): EsmModuleTypeResult {
+  const parsed = JSON.parse(existing) as Record<string, unknown>;
+  const currentType = parsed['type'];
+
+  if (currentType === 'module') {
+    return { content: null, warning: null };
+  }
+
+  if (typeof currentType === 'string' && currentType !== 'module') {
+    return {
+      content: null,
+      warning: `package.json declares "type": "${currentType}" — keeping yours, but the scaffolded prisma/db.ts uses an ESM-only import attribute (\`with { type: 'json' }\`) and will not load under that module type.\nIf you want the default, set "type": "module" in package.json.`,
+    };
+  }
+
+  const next: Record<string, unknown> = {};
+  let inserted = false;
+  for (const [key, value] of Object.entries(parsed)) {
+    // A non-string `type` slipped past the early-return guards above
+    // (those only fire for `'module'` and other strings). Skip it so the
+    // normalised `'module'` we inject below cannot be overwritten when
+    // `type` appears after `name` in key order.
+    if (key === 'type') continue;
+    next[key] = value;
+    if (!inserted && key === 'name') {
+      next['type'] = 'module';
+      inserted = true;
+    }
+  }
+  if (!inserted) {
+    next['type'] = 'module';
+  }
+
+  const trailingNewline = existing.endsWith('\n') ? '\n' : '';
+  return { content: `${JSON.stringify(next, null, 2)}${trailingNewline}`, warning: null };
+}

package/src/commands/init/init.ts

@@ -2,7 +2,7 @@ import { execFile } from 'node:child_process';
 import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
 import { promisify } from 'node:util';
 import * as clack from '@clack/prompts';
-import { dirname, isAbsolute, join } from 'pathe';
+import { basename, dirname, isAbsolute, join } from 'pathe';
 import { CliStructuredError } from '../../utils/cli-errors';
 import { formatErrorJson, formatErrorOutput } from '../../utils/formatters/errors';
 import type { GlobalFlags } from '../../utils/global-flags';
@@ -21,7 +21,6 @@ import {
   errorInitInstallFailed,
   errorInitInvalidManifest,
   errorInitInvalidTsconfig,
-  errorInitMissingManifest,
   errorInitProbeFailed,
 } from './errors';
 import {
@@ -34,7 +33,11 @@ import {
 } from './exit-codes';
 import { mergeGitattributes, requiredGitattributesLines } from './hygiene-gitattributes';
 import { mergeGitignore } from './hygiene-gitignore';
-import { mergePackageScripts, REQUIRED_SCRIPTS } from './hygiene-package-scripts';
+import {
+  ensureEsmModuleType,
+  mergePackageScripts,
+  REQUIRED_SCRIPTS,
+} from './hygiene-package-scripts';
 import { type InitFlagOptions, type ResolvedInitInputs, resolveInitInputs } from './inputs';
 import {
   buildNextSteps,
@@ -115,10 +118,6 @@ export async function runInit(
     clack.intro('prisma-next init', { output: process.stderr });
   }
 
-  if (!hasProjectManifest(baseDir)) {
-    return emitError(ui, flags, errorInitMissingManifest());
-  }
-
   let inputs: ResolvedInitInputs;
   try {
     inputs = await resolveInitInputs({ baseDir, options, flags, canPrompt });
@@ -244,10 +243,21 @@ export async function runInit(
   // the FR2.1 `@types/node`-presence check. A malformed manifest is
   // mapped to a structured precondition error (5010) rather than the
   // generic INTERNAL_ERROR fallback so CI/agents can branch on it.
+  //
+  // When neither `package.json` nor a `deno.json[c]` is present, init
+  // synthesises a minimal `package.json` (TML-2496) — running
+  // `npm init -y` first was friction with no upside, since we always
+  // edit the file anyway. A `deno.json[c]` project is left alone:
+  // creating a `package.json` next to it would fork the project's
+  // dependency graph.
   const packageJsonPath = join(baseDir, 'package.json');
+  const packageJsonExisted = existsSync(packageJsonPath);
+  const synthesisePackageJson = !packageJsonExisted && !hasProjectManifest(baseDir);
   let parsedPackageJson: Record<string, unknown> | null = null;
-  if (existsSync(packageJsonPath)) {
-    const pkgRaw = readFileSync(packageJsonPath, 'utf-8');
+  if (packageJsonExisted || synthesisePackageJson) {
+    const pkgRaw = packageJsonExisted
+      ? readFileSync(packageJsonPath, 'utf-8')
+      : defaultPackageJsonContent(basename(baseDir));
     try {
       parsedPackageJson = JSON.parse(pkgRaw) as Record<string, unknown>;
     } catch (err) {
@@ -262,11 +272,16 @@ export async function runInit(
     }
 
     // package.json edits are chained: FR9.2 facade-dep removal first
-    // (so the script merge sees the cleaned `dependencies` and rounds
+    // (so the later passes see the cleaned `dependencies` and we round
     // out a single re-stringification), then FR3.5 / FR9.3 idempotent
-    // scripts merge with collision detection.
+    // scripts merge with collision detection, then `"type": "module"`
+    // alignment so the ESM-only `with { type: 'json' }` import attribute
+    // in the scaffolded `prisma/db.ts` loads cleanly under Node's
+    // loader (TML-2494).
     let workingPkg = pkgRaw;
-    let pkgChanged = false;
+    // A synthesised manifest is always a write — the file does not
+    // exist on disk yet.
+    let pkgChanged = synthesisePackageJson;
     if (inputs.removePreviousFacade !== null) {
       const next = removeDependency(workingPkg, inputs.removePreviousFacade);
       if (next !== null) {
@@ -282,10 +297,23 @@ export async function runInit(
       workingPkg = nextPkg;
       pkgChanged = true;
     }
+    const { content: typedPkg, warning: typeWarning } = ensureEsmModuleType(workingPkg);
+    if (typedPkg !== null) {
+      workingPkg = typedPkg;
+      pkgChanged = true;
+    }
     if (pkgChanged) {
       filesToWrite.push({ path: 'package.json', content: workingPkg });
     }
     warnings.push(...scriptWarnings);
+    if (typeWarning !== null) {
+      warnings.push(typeWarning);
+    }
+    if (synthesisePackageJson) {
+      warnings.push(
+        'No package.json found in the target directory; created a minimal one. Edit `name` / `version` to taste.',
+      );
+    }
   }
 
   // -----------------------------------------------------------------
@@ -481,7 +509,6 @@ function emitError(ui: TerminalUI, flags: GlobalFlags, error: CliStructuredError
  */
 export function exitCodeForError(error: { readonly code: string }): number {
   switch (error.code) {
-    case '5001': // missing manifest — precondition
     case '5002': // re-init needs --force — precondition
     case '5003': // missing flags — precondition
     case '5004': // invalid flag value — precondition
@@ -823,3 +850,44 @@ function causeMessage(err: unknown): string {
   if (err instanceof Error) return err.message;
   return String(err);
 }
+
+/**
+ * Minimal `package.json` content used when init runs in a directory
+ * that has no project manifest (TML-2496). Mirrors the npm 11 `init -y`
+ * defaults, with two deliberate deviations:
+ *
+ * - `"private": true` so a stray `npm publish` cannot leak the
+ *   placeholder. Users who want to publish have to opt in by removing
+ *   the field.
+ * - `"type": "module"` so the scaffolded ESM imports in
+ *   `prisma-next.config.ts` and `db.ts` typecheck and run without
+ *   additional tsconfig coercion.
+ *
+ * Exported for unit tests so the canonical shape is asserted in one
+ * place rather than re-derived at every call site.
+ */
+export function defaultPackageJsonContent(rawName: string): string {
+  return `${JSON.stringify(
+    {
+      name: sanitisePackageName(rawName),
+      version: '0.0.0',
+      private: true,
+      type: 'module',
+    },
+    null,
+    2,
+  )}\n`;
+}
+
+/**
+ * npm package names are restricted to lowercase, no leading dot/underscore,
+ * and a small URL-safe character set. `basename(cwd)` happily returns
+ * "My Project" or ".hidden" — both rejected by `npm install` validation.
+ * Coerce to a safe fallback rather than emit a manifest npm refuses to
+ * read.
+ */
+function sanitisePackageName(raw: string): string {
+  const lowered = raw.toLowerCase().replace(/[^a-z0-9._~-]/g, '-');
+  const trimmed = lowered.replace(/^[._-]+/, '').replace(/-+/g, '-');
+  return trimmed.length > 0 ? trimmed : 'my-app';
+}