@prisma-next/cli 0.10.0 → 0.11.0-dev.10

package/src/commands/init/index.ts

@@ -4,7 +4,8 @@ import {
   setCommandDescriptions,
   setCommandExamples,
 } from '../../utils/command-helpers';
-import { type CommonCommandOptions, parseGlobalFlags } from '../../utils/global-flags';
+import { type CommonCommandOptions, parseGlobalFlagsOrExit } from '../../utils/global-flags';
+import { fireTelemetryAfterInitConsent } from '../../utils/telemetry';
 import {
   INIT_EXIT_EMIT_FAILED,
   INIT_EXIT_INSTALL_FAILED,
@@ -14,6 +15,7 @@ import {
   INIT_EXIT_SKILL_INSTALL_FAILED,
   INIT_EXIT_USER_ABORTED,
 } from './exit-codes';
+import { defaultSchemaPath } from './templates/code-templates';
 
 /**
  * Commander.js parsed options for `init`. The init-specific options live
@@ -63,7 +65,7 @@ export function createInitCommand(): Command {
     'prisma-next init --yes --target mongodb --authoring typescript --json',
     'prisma-next init --yes --force --target postgres --authoring psl  # overwrite an existing scaffold',
     'prisma-next init --no-install                                       # skip pnpm/npm install + emit',
-    'prisma-next init --no-skill                                         # skip the agent-skill install (air-gapped / restricted env)',
+    'prisma-next init --no-skill                                         # skip the skills install (air-gapped / restricted env)',
   ]);
 
   return addGlobalOptions(command)
@@ -71,7 +73,7 @@ export function createInitCommand(): Command {
     .option('--authoring <style>', 'Schema authoring style: psl or typescript')
     .option(
       '--schema-path <path>',
-      'Where to write the starter schema (default: prisma/contract.prisma)',
+      `Where to write the starter schema (default: ${defaultSchemaPath('psl')})`,
     )
     .option('--force', 'Overwrite an existing scaffold without prompting')
     .option(
@@ -91,15 +93,22 @@ export function createInitCommand(): Command {
       '--no-skill',
       'Skip Prisma Next skills install (air-gapped CI, restricted registries, etc.)',
     )
-    .action(async (options: InitCommandOptions) => {
+    .action(async (options: InitCommandOptions, actionCommand: Command) => {
       const { runInit } = await import('./init');
-      const flags = parseGlobalFlags(options);
+      const flags = parseGlobalFlagsOrExit(options);
       const canPrompt = deriveCanPrompt({
         flagsInteractive: flags.interactive,
         optionInteractive: options.interactive,
         stdinIsTTY: Boolean(process.stdin.isTTY),
       });
-      const exitCode = await runInit(process.cwd(), { options, flags, canPrompt });
+      const exitCode = await runInit(process.cwd(), {
+        options,
+        flags,
+        canPrompt,
+        afterFirstTelemetryConsent: (inputs) => {
+          fireTelemetryAfterInitConsent(actionCommand, { databaseTarget: inputs.target });
+        },
+      });
       process.exit(exitCode);
     });
 }

package/src/commands/init/init.ts

@@ -6,14 +6,7 @@ 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';
-import { TerminalUI } from '../../utils/terminal-ui';
-import {
-  DEFAULT_AGENT_SKILL_SOURCES,
-  formatClaudeSkillInstallCommand,
-  formatSkillInstallCommand,
-  LEGACY_SKILL_FILE,
-  runProjectLevelSkillInstall,
-} from './agent-skill-install';
+import { createTerminalUI, type TerminalUI } from '../../utils/terminal-ui';
 import {
   detectPackageManager,
   formatAddArgs,
@@ -56,9 +49,16 @@ import {
 } from './output';
 import { type ProbeOutcome, type ProbeOverrides, probeServerVersion } from './probe-db';
 import { findStaleArtefacts, removeDependency } from './reinit-cleanup';
+import {
+  DEFAULT_SKILL_SOURCES,
+  formatSkillInstallCommand,
+  LEGACY_SKILL_FILE,
+  runProjectLevelSkillInstall,
+} from './skill-install';
 import { configFile, dbFile, starterSchema, targetPackageName } from './templates/code-templates';
 import { envExampleContent, envFileContent, MIN_SERVER_VERSION } from './templates/env';
 import { quickReferenceMd } from './templates/quick-reference';
+import { minimalProjectReadmeMd } from './templates/readme';
 import { defaultTsConfig, mergeTsConfig, TsConfigParseError } from './templates/tsconfig';
 
 interface FileEntry {
@@ -81,11 +81,11 @@ interface InstallReport {
   readonly warnings: readonly string[];
   /**
    * The package manager that actually ran. Equal to the detected `pm`
-   * on the common path; differs when the FR7.2 pnpm → npm fallback
-   * fired, in which case it's `'npm'`. Threaded into the agent-skill
-   * install so the runner stays consistent with the install we just
-   * ran — re-trying through `pnpm dlx` when `pnpm install` just failed
-   * for workspace/catalog reasons would fail again for the same reason.
+   * on the common path; differs when the pnpm → npm fallback fired, in
+   * which case it's `'npm'`. Threaded into the skills install so the
+   * runner stays consistent with the install we just ran — re-trying
+   * through `pnpm dlx` when `pnpm install` just failed for
+   * workspace/catalog reasons would fail again for the same reason.
    */
   readonly effectivePm: PackageManager;
 }
@@ -95,7 +95,7 @@ interface InstallReport {
  * structured CLI errors raised at every phase (input resolution, install,
  * emit) and renders them via the same UI surface as success output
  * (`--json` to stdout, human to stderr). Exit codes follow the documented
- * stable set in `./exit-codes.ts` (FR1.6) and the
+ * stable set in `./exit-codes.ts` and the
  * [Style Guide § Exit Codes](../../../../../../../docs/CLI%20Style%20Guide.md#exit-codes).
  *
  * Layered for testability: the action handler in `./index.ts` is
@@ -113,6 +113,11 @@ export async function runInit(
      * mode) — see [Style Guide § Interactivity](../../../../../../../docs/CLI%20Style%20Guide.md#interactivity).
      */
     readonly canPrompt: boolean;
+    /**
+     * Called once after the first affirmative telemetry consent is persisted.
+     * Failures are swallowed by the caller; init success must not depend on telemetry.
+     */
+    readonly afterFirstTelemetryConsent?: (inputs: ResolvedInitInputs) => void | Promise<void>;
     /**
      * FR8.3 — test-only seam for the optional database version probe.
      * Production callers omit this; tests inject stub `probePostgres` /
@@ -124,8 +129,8 @@ export async function runInit(
     readonly probeOverrides?: ProbeOverrides;
   },
 ): Promise<number> {
-  const { options, flags, canPrompt, probeOverrides } = runOptions;
-  const ui = new TerminalUI({ color: flags.color, interactive: flags.interactive });
+  const { options, flags, canPrompt, probeOverrides, afterFirstTelemetryConsent } = runOptions;
+  const ui = createTerminalUI(flags);
   const warnings: string[] = [];
   const filesWritten: string[] = [];
   const filesDeleted: string[] = [];
@@ -144,6 +149,14 @@ export async function runInit(
     throw error;
   }
 
+  if (inputs.enableTelemetry === true && afterFirstTelemetryConsent !== undefined) {
+    try {
+      await afterFirstTelemetryConsent(inputs);
+    } catch {
+      // telemetry is best-effort and must never affect init
+    }
+  }
+
   const pm = await detectPackageManager(baseDir);
   const pkgRun = formatRunCommand(pm, 'prisma-next', '').trimEnd();
 
@@ -336,6 +349,26 @@ export async function runInit(
     }
   }
 
+  if (existsSync(join(baseDir, 'src/index.ts'))) {
+    if (!existsSync(join(baseDir, 'README.md'))) {
+      const rawName =
+        parsedPackageJson !== null && typeof parsedPackageJson['name'] === 'string'
+          ? parsedPackageJson['name']
+          : basename(baseDir);
+      filesToWrite.push({
+        path: 'README.md',
+        content: minimalProjectReadmeMd(
+          inputs.target,
+          inputs.schemaPath,
+          sanitisePackageName(rawName),
+          pm,
+        ),
+      });
+    } else {
+      warnings.push('README.md already exists; leaving it untouched.');
+    }
+  }
+
   // -----------------------------------------------------------------
   // Write phase — every input has been parsed and every merged file is
   // staged. From here on, failures are only possible at the
@@ -445,25 +478,20 @@ export async function runInit(
   // framework relies on. A project-level failure is fatal
   // (`INIT_EXIT_SKILL_INSTALL_FAILED`).
   //
-  // Runs after install + emit because (1) `node_modules` is in place,
-  // so any consumers downstream are coherent, and (2) the user has
-  // seen the scaffolding succeed before this network-bound step
-  // potentially fails. We skip the install when the user passed
-  // `--no-install` for the same reason — no `node_modules` means the
-  // workspace isn't ready to consume the skill yet anyway.
-  const manualProjectSkillCommands = DEFAULT_AGENT_SKILL_SOURCES.flatMap((source) => [
-    formatSkillInstallCommand(install.effectivePm, source),
-    formatClaudeSkillInstallCommand(install.effectivePm, source),
-  ]);
+  // Runs after the install + emit phase when those steps are enabled,
+  // but is not coupled to them: the skills are pulled directly from
+  // the Prisma Next GitHub repo and do not require `node_modules`.
+  // `--no-install` therefore skips only dependency installation and
+  // contract emission; `--no-skill` is the explicit escape hatch for
+  // skipping skills.
+  const manualProjectSkillCommands = DEFAULT_SKILL_SOURCES.map((source) =>
+    formatSkillInstallCommand({ pm: install.effectivePm, source }),
+  );
   const manualProjectSkillSummary = manualProjectSkillCommands.map((c) => `\`${c}\``).join(' && ');
   let skillRegistered = false;
   if (!inputs.installProjectSkill) {
     warnings.push(
-      `Skipped Prisma Next agent-skill install (--no-skill). To install the skills later, run: ${manualProjectSkillSummary}`,
-    );
-  } else if (install.skipped) {
-    warnings.push(
-      `Skipped Prisma Next agent-skill install because --no-install was passed. After you run install manually, install the skills with: ${manualProjectSkillSummary}`,
+      `Skipped Prisma Next skills install (--no-skill). To install the skills later, run: ${manualProjectSkillSummary}`,
     );
   } else {
     const spinner = ui.spinner();
@@ -588,6 +616,7 @@ export function exitCodeForError(error: { readonly code: string }): number {
     case '5010': // invalid manifest (malformed package.json) — precondition
     case '5011': // invalid tsconfig (unparseable JSONC) — precondition
     case '5012': // probe failed under --strict-probe — precondition
+    case '5014': // --authoring / --schema-path extension mismatch — precondition
       return INIT_EXIT_PRECONDITION;
     case '5006': // user aborted interactive prompt
       return INIT_EXIT_USER_ABORTED;
@@ -597,7 +626,7 @@ export function exitCodeForError(error: { readonly code: string }): number {
       return INIT_EXIT_EMIT_FAILED;
     case '5009': // invalid output document — internal bug in prisma-next
       return INIT_EXIT_INTERNAL_ERROR;
-    case '5013': // agent-skill install failed
+    case '5013': // skill install failed
       return INIT_EXIT_SKILL_INSTALL_FAILED;
     default:
       // Any unexpected code is treated as an internal bug rather than

package/src/commands/init/inputs.ts

@@ -1,8 +1,11 @@
 import { existsSync, readFileSync } from 'node:fs';
 import * as clack from '@clack/prompts';
+import { readUserConfig, resolveGating, writeUserConfig } from '@prisma-next/cli-telemetry';
 import { extname, join, normalize } from 'pathe';
 import type { GlobalFlags } from '../../utils/global-flags';
+import { isCI } from '../../utils/is-ci';
 import {
+  errorInitAuthoringSchemaPathMismatch,
   errorInitInvalidFlagValue,
   errorInitMissingFlags,
   errorInitReinitNeedsForce,
@@ -68,12 +71,24 @@ export interface ResolvedInitInputs {
    * is added separately via the install step.
    */
   readonly removePreviousFacade: string | null;
+  /**
+   * Telemetry consent answer recorded during this `init` run, or `null`
+   * when no prompt was shown. The prompt fires only on the
+   * canPrompt + !autoAcceptPrompts + no env/CI opt-out +
+   * `enableTelemetry === undefined` intersection; outside that window
+   * the field is `null` and the stored preference (if any) stays
+   * unchanged. The answer has already been persisted to
+   * `$XDG_CONFIG_HOME/prisma-next/config.json` by
+   * the time `runInit` sees this value — it's surfaced here purely so
+   * the post-init summary can mention what the user chose.
+   */
+  readonly enableTelemetry: boolean | null;
   /**
    * Whether to run `npx skills add prisma/prisma-next#v<version>` at the
    * project level after install + emit. True by default; `--no-skill`
    * sets it to `false`. The skill is always project-level (never
    * user-level / global) so its version stays locked to the project's
-   * Prisma Next version — see `agent-skill-install.ts`.
+   * Prisma Next version — see `skill-install.ts`.
    */
   readonly installProjectSkill: boolean;
 }
@@ -91,6 +106,12 @@ const AUTHORING_VALUES: ReadonlyMap<string, AuthoringId> = new Map([
   ['ts', 'typescript'],
 ]);
 
+export const TELEMETRY_CONSENT_MESSAGE = [
+  'Help us prioritize features by sharing anonymous CLI usage data?',
+  'The telemetry implementation is open source and fully transparent.',
+  '(packages/1-framework/3-tooling/cli-telemetry and apps/telemetry-backend).',
+].join(' ');
+
 /**
  * Resolves every required input for `runInit`. In interactive mode, missing
  * inputs are prompted via clack; in non-interactive mode, missing required
@@ -176,6 +197,11 @@ export async function resolveInitInputs(ctx: {
     autoAcceptPrompts,
   });
 
+  const enableTelemetry = await resolveTelemetryConsent({
+    canPrompt,
+    autoAcceptPrompts,
+  });
+
   // Skill-install gating. `--no-skill` (commander parses
   // `options.skill === false`) is the only escape hatch; otherwise
   // project-level install is unconditional. The skill is always
@@ -193,10 +219,60 @@ export async function resolveInitInputs(ctx: {
     strictProbe: Boolean(options.strictProbe),
     reinit,
     removePreviousFacade,
+    enableTelemetry,
     installProjectSkill,
   };
 }
 
+/**
+ * The interactive telemetry consent prompt. Shown as the last
+ * question of the `init` sequence iff:
+ *   1. `canPrompt === true` (interactive stdin / stdout combo),
+ *   2. `autoAcceptPrompts === false` (the user did not pass `--yes`),
+ *   3. neither telemetry env opt-out is active,
+ *   4. the process is not running in CI,
+ *   5. the stored `enableTelemetry` value is `undefined` (the user
+ *      has never been asked, or skipped the prompt previously).
+ *
+ * Outside that intersection the function returns `null` and leaves the
+ * stored preference untouched. Inside it, the user's answer is
+ * persisted via `writeUserConfig({ enableTelemetry })` before this
+ * function returns; on an affirmative answer `writeUserConfig`
+ * generates and stores the v4 `installationId` in the same write.
+ *
+ * The wording names CLI usage data and points to the open-source
+ * client/backend paths. Default value is `true` to match precedent
+ * and to make the consent answer a single keystroke once it's been
+ * disclosed.
+ */
+async function resolveTelemetryConsent(opts: {
+  readonly canPrompt: boolean;
+  readonly autoAcceptPrompts: boolean;
+}): Promise<boolean | null> {
+  if (!opts.canPrompt || opts.autoAcceptPrompts || isCI()) {
+    return null;
+  }
+  const config = readUserConfig();
+  const gating = resolveGating({ env: process.env, config });
+  if (!gating.enabled && gating.reason === 'env-override') {
+    return null;
+  }
+  const stored = config.enableTelemetry;
+  if (stored !== undefined) {
+    return null;
+  }
+  const result = await clack.confirm({
+    message: TELEMETRY_CONSENT_MESSAGE,
+    initialValue: true,
+    output: process.stderr,
+  });
+  if (clack.isCancel(result)) {
+    throw errorInitUserAborted();
+  }
+  writeUserConfig({ enableTelemetry: Boolean(result) });
+  return Boolean(result);
+}
+
 async function resolveWriteEnv(opts: {
   readonly flag: boolean | undefined;
   readonly canPrompt: boolean;
@@ -376,10 +452,11 @@ function validateSchemaPath(value: string, authoring: AuthoringId): string {
   const ext = extname(trimmed).toLowerCase();
   const expected = authoring === 'typescript' ? '.ts' : '.prisma';
   if (ext !== expected) {
-    throw errorInitInvalidFlagValue({
-      flag: 'schema-path',
-      value,
-      allowed: [`<file path ending in ${expected} for --authoring ${authoring}>`],
+    throw errorInitAuthoringSchemaPathMismatch({
+      authoring,
+      schemaPath: trimmed,
+      actualExtension: ext.length > 0 ? ext : '(none)',
+      expectedExtension: expected,
     });
   }
   return normalize(trimmed);

package/src/commands/init/output.ts

@@ -123,7 +123,7 @@ export function buildNextSteps(options: {
   /**
    * Whether the project-level Prisma Next skills install actually ran
    * and succeeded during this `init`. When false (the user passed
-   * `--no-skill` or `--no-install`, so the install was skipped), the
+   * `--no-skill`, so the install was skipped), the
    * "registered with your agent runtime" step is omitted — the skip is
    * already surfaced in the warnings array with a manual-install hint.
    */

package/src/commands/init/{agent-skill-install.ts → skill-install.ts}

@@ -11,12 +11,12 @@ const exec = promisify(execFile);
  * upstream `skills add`. Each `SkillSource` joins this base with its
  * own subpath (and optional `#ref` for version-pinned clusters).
  */
-export const DEFAULT_AGENT_SKILL_BASE = 'prisma/prisma-next';
+export const DEFAULT_SKILL_BASE = 'prisma/prisma-next';
 
 /**
  * One discovery scope inside the Prisma Next monorepo. The CLI emits
- * one `skills add <base>/<subpath>[#ref] --all` invocation per source
- * during `init`.
+ * one `skills add <base>/<subpath>[#ref] --agent ... --skill '*' -y`
+ * invocation per source during `init`.
  *
  * `ref` semantics:
  * - `cli`: pin to the CLI's own package version (lockstep with the
@@ -35,7 +35,7 @@ export interface SkillSource {
   readonly description: string;
 }
 
-export const DEFAULT_AGENT_SKILL_SOURCES: readonly SkillSource[] = [
+export const DEFAULT_SKILL_SOURCES: readonly SkillSource[] = [
   {
     subpath: 'skills',
     ref: 'cli',
@@ -56,7 +56,7 @@ export const DEFAULT_AGENT_SKILL_SOURCES: readonly SkillSource[] = [
 /**
  * Test-only escape hatch for pinning the install base to a local
  * checkout. Production runs leave this unset, so installs always use
- * `DEFAULT_AGENT_SKILL_BASE`.
+ * `DEFAULT_SKILL_BASE`.
  *
  * When set to an absolute filesystem path (typical for tests), the
  * `#ref` fragment is dropped — local-path mode in upstream's CLI does
@@ -66,13 +66,28 @@ export const DEFAULT_AGENT_SKILL_SOURCES: readonly SkillSource[] = [
  */
 function resolveAgentSkillBase(): string {
   const override = process.env['PRISMA_NEXT_SKILLS_BASE']?.trim();
-  return override && override.length > 0 ? override : DEFAULT_AGENT_SKILL_BASE;
+  return override && override.length > 0 ? override : DEFAULT_SKILL_BASE;
 }
 
 function isLocalPath(base: string): boolean {
   return base.startsWith('/') || /^[a-zA-Z]:[\\/]/.test(base);
 }
 
+/** Agent slugs accepted by the upstream `skills add --agent` flag. */
+export type SkillAgent = 'cursor' | 'claude-code' | 'codex' | 'windsurf';
+
+/**
+ * Agents passed to every project-level init install. Upstream `skills add`
+ * is the source of truth for per-agent install behaviour; the CLI lists
+ * every supported runtime on one invocation and delegates the rest.
+ */
+export const DEFAULT_SKILL_AGENTS: readonly SkillAgent[] = [
+  'cursor',
+  'claude-code',
+  'codex',
+  'windsurf',
+];
+
 /**
  * Build the `<base>/<subpath>[#ref]` URL the `skills` CLI will
  * resolve. Exported for unit tests so the per-source format can be
@@ -94,37 +109,36 @@ export function formatSkillSourceUrl(source: SkillSource): string {
  * rest of the install step so a single project consistently uses one
  * runner.
  *
- * `--all` auto-selects every skill in the cluster and every detected
- * agent runtime, skipping the multi-select prompts the `skills` CLI
- * shows by default. A non-interactive scaffold step cannot present
- * prompts.
+ * `--agent` takes space-separated slugs on one flag; `--skill '*'` and `-y`
+ * skip the multi-select prompts a non-interactive scaffold step cannot show.
  *
  * Exported for unit tests so the per-PM dispatch can be asserted
  * without a live subprocess.
  */
-export function formatSkillInstallCommand(pm: PackageManager, source: SkillSource): string {
-  const args = ['skills@latest', 'add', formatSkillSourceUrl(source), '--all'];
-  return formatPackageManagerCommand(pm, args);
-}
-
-/**
- * `skills add --all` should cover Claude Code, but upstream currently skips
- * project-local Claude symlinks when `.claude/` does not already exist. Run
- * the explicit Claude Code install as well so fresh projects get
- * `.claude/skills` without asking users to create that folder first.
- */
-export function formatClaudeSkillInstallCommand(pm: PackageManager, source: SkillSource): string {
-  const args = [
+export function formatSkillInstallCommand(args: {
+  readonly pm: PackageManager;
+  readonly source: SkillSource;
+  readonly agents?: readonly SkillAgent[];
+}): string {
+  const agents = args.agents ?? DEFAULT_SKILL_AGENTS;
+  const cliArgs = [
     'skills@latest',
     'add',
-    formatSkillSourceUrl(source),
+    formatSkillSourceUrl(args.source),
     '--agent',
-    'claude-code',
+    ...agents,
     '--skill',
     "'*'",
     '-y',
   ];
-  return formatPackageManagerCommand(pm, args);
+  return formatPackageManagerCommand(args.pm, cliArgs);
+}
+
+/**
+ * Ordered skill-install commands for one init run. Exported for unit tests.
+ */
+export function resolveProjectSkillInstallCommands(pm: PackageManager): readonly string[] {
+  return DEFAULT_SKILL_SOURCES.map((source) => formatSkillInstallCommand({ pm, source }));
 }
 
 function formatPackageManagerCommand(pm: PackageManager, args: readonly string[]): string {
@@ -162,7 +176,7 @@ function commandToExec(command: string): {
 
 /**
  * Runs the project-level skill install for every source in
- * `DEFAULT_AGENT_SKILL_SOURCES`, in order. Returns
+ * `DEFAULT_SKILL_SOURCES`, in order. Returns
  * `{ ok: true, commands }` on success; throws a structured
  * `errorInitSkillInstallFailed` on the first failure (subsequent
  * sources are not attempted — the user opted into Prisma Next by
@@ -176,10 +190,7 @@ export async function runProjectLevelSkillInstall(ctx: {
   readonly filesWritten: readonly string[];
 }): Promise<{ readonly ok: true; readonly commands: readonly string[] }> {
   const commands: string[] = [];
-  const installCommands = DEFAULT_AGENT_SKILL_SOURCES.flatMap((source) => [
-    formatSkillInstallCommand(ctx.pm, source),
-    formatClaudeSkillInstallCommand(ctx.pm, source),
-  ]);
+  const installCommands = resolveProjectSkillInstallCommands(ctx.pm);
 
   for (const command of installCommands) {
     const { file, args } = commandToExec(command);

package/src/commands/init/templates/code-templates.ts

@@ -1,3 +1,5 @@
+import { DEFAULT_CONTRACT_SOURCE_DIR } from '@prisma-next/config/config-types';
+
 export type TargetId = 'postgres' | 'mongo';
 export type AuthoringId = 'psl' | 'typescript';
 
@@ -11,9 +13,9 @@ export function targetLabel(target: TargetId): string {
 
 export function defaultSchemaPath(authoring: AuthoringId): string {
   if (authoring === 'typescript') {
-    return 'prisma/contract.ts';
+    return `${DEFAULT_CONTRACT_SOURCE_DIR}/contract.ts`;
   }
-  return 'prisma/contract.prisma';
+  return `${DEFAULT_CONTRACT_SOURCE_DIR}/contract.prisma`;
 }
 
 export function starterSchema(target: TargetId, authoring: AuthoringId): string {
@@ -42,9 +44,10 @@ export function schemaSample(target: TargetId, authoring: AuthoringId): string {
 function schemaSamplePslPostgres(): string {
   return `\`\`\`prisma
 model User {
-  id    Int     @id @default(autoincrement())
-  email String  @unique
-  name  String?
+  id       Int     @id @default(autoincrement())
+  email    String  @unique
+  username String?
+  name     String?
 }
 \`\`\``;
 }
@@ -52,9 +55,10 @@ model User {
 function schemaSamplePslMongo(): string {
   return `\`\`\`prisma
 model User {
-  id    ObjectId @id @map("_id")
-  email String   @unique
-  name  String?
+  id       ObjectId @id @map("_id")
+  email    String   @unique
+  username String?
+  name     String?
   @@map("users")
 }
 \`\`\``;
@@ -63,17 +67,16 @@ model User {
 function schemaSampleTsPostgres(): string {
   return `\`\`\`typescript
 import { defineContract } from '@prisma-next/postgres/contract-builder';
-import sqlFamily from '@prisma-next/postgres/family';
-import postgresTarget from '@prisma-next/postgres/target';
 
 export const contract = defineContract(
-  { family: sqlFamily, target: postgresTarget },
+  {},
   ({ field, model }) => ({
     models: {
       User: model('User', {
         fields: {
           id: field.id.uuidv7(),
           email: field.text().unique(),
+          username: field.text().optional(),
           name: field.text().optional(),
         },
       }),
@@ -86,11 +89,9 @@ export const contract = defineContract(
 function schemaSampleTsMongo(): string {
   return `\`\`\`typescript
 import { defineContract } from '@prisma-next/mongo/contract-builder';
-import mongoFamily from '@prisma-next/mongo/family';
-import mongoTarget from '@prisma-next/mongo/target';
 
 export const contract = defineContract(
-  { family: mongoFamily, target: mongoTarget },
+  {},
   ({ field, model }) => ({
     models: {
       User: model('User', {
@@ -98,6 +99,7 @@ export const contract = defineContract(
         fields: {
           _id: field.objectId(),
           email: field.string(),
+          username: field.string().optional(),
           name: field.string().optional(),
         },
       }),
@@ -113,6 +115,7 @@ function starterSchemaPslPostgres(): string {
 model User {
   id        Int      @id @default(autoincrement())
   email     String   @unique
+  username  String?
   name      String?
   posts     Post[]
   createdAt DateTime @default(now())
@@ -135,10 +138,11 @@ function starterSchemaPslMongo(): string {
   return `// use prisma-next
 
 model User {
-  id    ObjectId @id @map("_id")
-  email String   @unique
-  name  String?
-  posts Post[]
+  id       ObjectId @id @map("_id")
+  email    String   @unique
+  username String?
+  name     String?
+  posts    Post[]
   @@map("users")
 }
 
@@ -155,17 +159,16 @@ model Post {
 
 function starterSchemaTsPostgres(): string {
   return `import { defineContract } from '@prisma-next/postgres/contract-builder';
-import sqlFamily from '@prisma-next/postgres/family';
-import postgresTarget from '@prisma-next/postgres/target';
 
 export const contract = defineContract(
-  { family: sqlFamily, target: postgresTarget },
+  {},
   ({ field, model, rel }) => ({
     models: {
       User: model('User', {
         fields: {
           id: field.id.uuidv7(),
           email: field.text().unique(),
+          username: field.text().optional(),
           name: field.text().optional(),
           createdAt: field.temporal.createdAt(),
           updatedAt: field.temporal.updatedAt(),
@@ -196,11 +199,9 @@ export const contract = defineContract(
 
 function starterSchemaTsMongo(): string {
   return `import { defineContract } from '@prisma-next/mongo/contract-builder';
-import mongoFamily from '@prisma-next/mongo/family';
-import mongoTarget from '@prisma-next/mongo/target';
 
 export const contract = defineContract(
-  { family: mongoFamily, target: mongoTarget },
+  {},
   ({ field, model, rel }) => ({
     models: {
       User: model('User', {
@@ -208,6 +209,7 @@ export const contract = defineContract(
         fields: {
           _id: field.objectId(),
           email: field.string(),
+          username: field.string().optional(),
           name: field.string().optional(),
         },
         relations: {