@beignet/cli 0.0.47 → 0.0.49

package/src/registry-edits.ts

@@ -308,24 +308,324 @@ export function outboxRegistryValueInfo(
   source: string,
   property: "events" | "jobs",
 ): InitializerInfo | undefined {
-  const call = /\bdefineOutboxRegistry\s*(?:<[^>]*>\s*)?\(/.exec(source);
-  if (!call) return undefined;
+  const match = outboxRegistryPropertyAnalysis(source, property);
+  if (!match?.value || match.indeterminate) return undefined;
+  const start = match.value.getStart(match.sourceFile);
+  return {
+    text: source.slice(start, match.value.end),
+    start,
+    end: match.value.end,
+  };
+}
+
+export type OutboxRegistryEntryState =
+  | "absent"
+  | "empty"
+  | "present"
+  | "indeterminate";
+
+/** Static state of one outbox registry property. */
+export function outboxRegistryEntryState(
+  source: string,
+  property: "events" | "jobs",
+): OutboxRegistryEntryState {
+  const match = outboxRegistryPropertyAnalysis(source, property);
+  if (!match) return "absent";
+  if (match.indeterminate) return "indeterminate";
+  if (!match.value) return "empty";
+  return resolvedRegistryExpressions(match.value, match.sourceFile).length > 0
+    ? "present"
+    : "empty";
+}
 
-  const openBrace = source.indexOf("{", call.index);
-  if (openBrace === -1) return undefined;
+/** Whether a registry property is non-empty or cannot be proven empty. */
+export function outboxRegistryHasEntries(
+  source: string,
+  property: "events" | "jobs",
+): boolean {
+  const state = outboxRegistryEntryState(source, property);
+  return state === "present" || state === "indeterminate";
+}
 
-  const closeBrace = matchingDelimiterIndex(source, openBrace, "{", "}");
-  if (closeBrace === -1) return undefined;
+/** Identifiers referenced by a registry property after resolving local array aliases. */
+export function outboxRegistryIdentifiers(
+  source: string,
+  property: "events" | "jobs",
+): Set<string> {
+  const match = outboxRegistryPropertyAnalysis(source, property);
+  if (!match?.value || match.indeterminate) return new Set();
+
+  const identifiers = new Set<string>();
+  for (const expression of resolvedRegistryExpressions(
+    match.value,
+    match.sourceFile,
+  )) {
+    const start = expression.getStart(match.sourceFile);
+    for (const identifier of identifiersFromArrayExpression(
+      source.slice(start, expression.end),
+    )) {
+      identifiers.add(identifier);
+    }
+  }
+  return identifiers;
+}
 
-  const objectText = source.slice(openBrace, closeBrace + 1);
-  const propertyMatch = new RegExp(`\\b${property}\\s*:`).exec(objectText);
-  if (!propertyMatch) return undefined;
+type OutboxRegistryPropertyAnalysis = {
+  sourceFile: ts.SourceFile;
+  value?: ts.Expression;
+  indeterminate: boolean;
+};
 
-  const valueStart = openBrace + propertyMatch.index + propertyMatch[0].length;
-  const value = topLevelValueSlice(source, valueStart, closeBrace);
-  if (!value) return undefined;
+function outboxRegistryPropertyAnalysis(
+  source: string,
+  property: "events" | "jobs",
+): OutboxRegistryPropertyAnalysis | undefined {
+  const sourceFile = ts.createSourceFile(
+    "outbox-registry.ts",
+    source,
+    ts.ScriptTarget.Latest,
+    true,
+    ts.ScriptKind.TS,
+  );
+  const initializers = registryInitializers(sourceFile);
+  const selected = selectOutboxRegistryCall(sourceFile);
+  if (!selected.call) {
+    return selected.indeterminate
+      ? { sourceFile, indeterminate: true }
+      : undefined;
+  }
 
-  return value;
+  const firstArgument = selected.call.arguments[0];
+  const object = firstArgument
+    ? resolveRegistryExpression(firstArgument, initializers)
+    : undefined;
+  if (!object || !ts.isObjectLiteralExpression(object)) {
+    return { sourceFile, indeterminate: true };
+  }
+
+  let value: ts.Expression | undefined;
+  let indeterminate = false;
+  for (const member of object.properties) {
+    if (ts.isSpreadAssignment(member)) {
+      value = undefined;
+      indeterminate = true;
+      continue;
+    }
+    const name = member.name ? registryPropertyName(member.name) : undefined;
+    if (!name) {
+      value = undefined;
+      indeterminate = true;
+      continue;
+    }
+    if (name !== property) continue;
+    if (
+      ts.isPropertyAssignment(member) ||
+      ts.isShorthandPropertyAssignment(member)
+    ) {
+      value = ts.isPropertyAssignment(member)
+        ? member.initializer
+        : member.name;
+      indeterminate = false;
+    } else {
+      value = undefined;
+      indeterminate = true;
+    }
+  }
+  if (value && !isStaticRegistryValue(value, initializers)) {
+    return { sourceFile, indeterminate: true };
+  }
+  return { sourceFile, value, indeterminate };
+}
+
+function isStaticRegistryValue(
+  expression: ts.Expression,
+  initializers: Map<string, ts.Expression>,
+  visited = new Set<string>(),
+): boolean {
+  const current = unwrapRegistryExpression(expression);
+  if (ts.isArrayLiteralExpression(current)) return true;
+  if (!ts.isIdentifier(current)) return false;
+
+  const initializer = initializers.get(current.text);
+  if (!initializer) return true;
+  if (visited.has(current.text)) return false;
+
+  const nextVisited = new Set(visited);
+  nextVisited.add(current.text);
+  return isStaticRegistryValue(initializer, initializers, nextVisited);
+}
+
+function selectOutboxRegistryCall(sourceFile: ts.SourceFile): {
+  call?: ts.CallExpression;
+  indeterminate: boolean;
+} {
+  const exportedNames = locallyExportedRegistryNames(sourceFile);
+  const candidates: {
+    name?: string;
+    exported: boolean;
+    calls: ts.CallExpression[];
+  }[] = [];
+
+  for (const statement of sourceFile.statements) {
+    if (!ts.isVariableStatement(statement)) continue;
+    const statementExported = Boolean(
+      statement.modifiers?.some(
+        (modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword,
+      ),
+    );
+    for (const declaration of statement.declarationList.declarations) {
+      if (!declaration.initializer) continue;
+      const calls = outboxRegistryCalls(declaration.initializer);
+      if (calls.length === 0) continue;
+      const name = ts.isIdentifier(declaration.name)
+        ? declaration.name.text
+        : undefined;
+      candidates.push({
+        ...(name ? { name } : {}),
+        exported: statementExported || (name ? exportedNames.has(name) : false),
+        calls,
+      });
+    }
+  }
+
+  const canonical = candidates.filter(
+    (candidate) => candidate.name === "outboxRegistry" && candidate.exported,
+  );
+  const exported = candidates.filter((candidate) => candidate.exported);
+  const selected =
+    canonical.length > 0
+      ? canonical
+      : exported.length > 0
+        ? exported
+        : candidates;
+  if (selected.length === 1 && selected[0].calls.length === 1) {
+    return { call: selected[0].calls[0], indeterminate: false };
+  }
+  if (selected.length > 0) return { indeterminate: true };
+
+  const fallback = outboxRegistryCalls(sourceFile);
+  return fallback.length === 1
+    ? { call: fallback[0], indeterminate: false }
+    : { indeterminate: fallback.length > 0 };
+}
+
+function locallyExportedRegistryNames(sourceFile: ts.SourceFile): Set<string> {
+  const names = new Set<string>();
+  for (const statement of sourceFile.statements) {
+    if (
+      !ts.isExportDeclaration(statement) ||
+      !statement.exportClause ||
+      !ts.isNamedExports(statement.exportClause) ||
+      statement.moduleSpecifier
+    ) {
+      continue;
+    }
+    for (const element of statement.exportClause.elements) {
+      names.add(element.propertyName?.text ?? element.name.text);
+    }
+  }
+  return names;
+}
+
+function outboxRegistryCalls(node: ts.Node): ts.CallExpression[] {
+  const calls: ts.CallExpression[] = [];
+  const visit = (child: ts.Node): void => {
+    if (
+      ts.isCallExpression(child) &&
+      ((ts.isIdentifier(child.expression) &&
+        child.expression.text === "defineOutboxRegistry") ||
+        (ts.isPropertyAccessExpression(child.expression) &&
+          child.expression.name.text === "defineOutboxRegistry"))
+    ) {
+      calls.push(child);
+    }
+    ts.forEachChild(child, visit);
+  };
+  visit(node);
+  return calls;
+}
+
+function resolvedRegistryExpressions(
+  expression: ts.Expression,
+  sourceFile: ts.SourceFile,
+): ts.Expression[] {
+  const initializers = registryInitializers(sourceFile);
+
+  const resolve = (
+    candidate: ts.Expression,
+    visited: Set<string>,
+  ): ts.Expression[] => {
+    const current = unwrapRegistryExpression(candidate);
+    if (ts.isArrayLiteralExpression(current)) {
+      return current.elements.flatMap((element) =>
+        ts.isSpreadElement(element)
+          ? resolve(element.expression, new Set(visited))
+          : ts.isExpression(element)
+            ? [element]
+            : [],
+      );
+    }
+    if (ts.isIdentifier(current) && !visited.has(current.text)) {
+      const initializer = initializers.get(current.text);
+      if (initializer) {
+        const nextVisited = new Set(visited);
+        nextVisited.add(current.text);
+        return resolve(initializer, nextVisited);
+      }
+    }
+    return [current];
+  };
+
+  return resolve(expression, new Set());
+}
+
+function registryInitializers(
+  sourceFile: ts.SourceFile,
+): Map<string, ts.Expression> {
+  const initializers = new Map<string, ts.Expression>();
+  for (const statement of sourceFile.statements) {
+    if (!ts.isVariableStatement(statement)) continue;
+    for (const declaration of statement.declarationList.declarations) {
+      if (ts.isIdentifier(declaration.name) && declaration.initializer) {
+        initializers.set(declaration.name.text, declaration.initializer);
+      }
+    }
+  }
+  return initializers;
+}
+
+function resolveRegistryExpression(
+  expression: ts.Expression,
+  initializers: Map<string, ts.Expression>,
+  visited = new Set<string>(),
+): ts.Expression {
+  const current = unwrapRegistryExpression(expression);
+  if (!ts.isIdentifier(current) || visited.has(current.text)) return current;
+  const initializer = initializers.get(current.text);
+  if (!initializer) return current;
+  const nextVisited = new Set(visited);
+  nextVisited.add(current.text);
+  return resolveRegistryExpression(initializer, initializers, nextVisited);
+}
+
+function unwrapRegistryExpression(expression: ts.Expression): ts.Expression {
+  let current = expression;
+  while (
+    ts.isParenthesizedExpression(current) ||
+    ts.isAsExpression(current) ||
+    ts.isSatisfiesExpression(current) ||
+    ts.isTypeAssertionExpression(current) ||
+    ts.isNonNullExpression(current)
+  ) {
+    current = current.expression;
+  }
+  return current;
+}
+
+function registryPropertyName(name: ts.PropertyName): string | undefined {
+  return ts.isIdentifier(name) || ts.isStringLiteralLike(name)
+    ? name.text
+    : undefined;
 }
 
 /**
@@ -390,53 +690,3 @@ function appendEntry(
   if (next === source) return { kind: "unchanged" };
   return { kind: "updated", source: next };
 }
-
-function topLevelValueSlice(
-  source: string,
-  valueStart: number,
-  hardEnd: number,
-): InitializerInfo | undefined {
-  let start = valueStart;
-  while (start < hardEnd && /\s/.test(source[start])) start++;
-  if (start >= hardEnd) return undefined;
-
-  let depth = 0;
-
-  for (const index of codeCharacterIndexes(source, start, hardEnd + 1)) {
-    const char = source[index];
-
-    if (char === "[" || char === "(" || char === "{") {
-      depth++;
-      continue;
-    }
-
-    if (char === "]" || char === ")" || char === "}") {
-      if (depth === 0) {
-        return trimmedInfo(source, start, index);
-      }
-      depth--;
-      continue;
-    }
-
-    if (char === "," && depth === 0) {
-      return trimmedInfo(source, start, index);
-    }
-  }
-
-  return undefined;
-}
-
-function trimmedInfo(
-  source: string,
-  start: number,
-  end: number,
-): InitializerInfo {
-  let trimmedEnd = end;
-  while (trimmedEnd > start && /\s/.test(source[trimmedEnd - 1])) trimmedEnd--;
-
-  return {
-    text: source.slice(start, trimmedEnd),
-    start,
-    end: trimmedEnd,
-  };
-}

package/src/templates/agents.ts

@@ -41,6 +41,9 @@ https://beignetjs.com (agent-friendly index at https://beignetjs.com/llms.txt).
 README.md covers setup and the app map; this file covers what is not
 discoverable from the code.
 
+This app requires Node.js 22.12 or newer. Bun 1.3.14 or newer is supported for
+Beignet commands.
+
 ## Registration is explicit
 
 Hand-writing an artifact file does not wire it into the app. Non-registration
@@ -54,6 +57,11 @@ is a silent failure — the file exists but never runs:
 - Tasks must be added to \`defineTasks([...])\` in \`server/tasks.ts\`.
 - Outbox events and jobs must be registered in \`defineOutboxRegistry({...})\`
   in \`server/outbox.ts\`.
+- An outbox registry containing jobs also requires \`jobs: JobDispatcherPort\`
+  to be bound directly or deferred to a provider. \`${cli} make job\` installs
+  an app-owned inline dispatcher only when no dispatcher is already wired;
+  adding an Inngest or BullMQ preset later replaces only that marked generated
+  fallback and rejects unmarked custom inline wiring as a conflict.
 - Listeners must be added to the \`listeners\` array in \`server/listeners.ts\`
   and wired through a \`registerListeners(...)\` call in server provider wiring.
 - Apps using Inngest must also spread feature job registries into
@@ -79,7 +87,8 @@ array anchors are unambiguous. It also syncs missing default Beignet
 provider-table exports when \`infra/db/schema/beignet.ts\` is missing or still
 matches \`${cli} db schema sync\` output and the schema index has no custom
 named re-export for that file. Run \`${cli} db generate\` and
-\`${cli} db migrate\` after accepting that source repair. Custom or ambiguous
+\`${cli} db migrate\`, then \`${cli} db status\` after accepting that source
+repair. Custom or ambiguous
 code stays diagnostic-only.
 
 ## Prefer generators
@@ -89,10 +98,12 @@ files — prefer it over hand-writing them. See \`${cli} make --help\` for the
 artifact list. Use \`${cli} make feature <name> --recipe full-slice\` when you
 need a richer reference slice with policy, client helpers, workflow artifacts,
 events, listener registration, jobs, and outbox wiring. After changing the Drizzle schema in
-\`infra/db/schema/\`, run \`${cli} db generate\` then \`${cli} db migrate\`.
+\`infra/db/schema/\`, run \`${cli} db generate\`, \`${cli} db migrate\`, then
+\`${cli} db status\`.
 When MCP is available, use \`db_schema_sync\` for Beignet provider table
 re-exports and \`db\` for \`generate\`, \`migrate\`, \`seed\`, or \`reset\`
-instead of falling back to a shell. Use \`task_run\`, \`schedule_run\`,
+instead of falling back to a shell. Use the read-only \`db_status\` tool before
+deploying. Use \`task_run\`, \`schedule_run\`,
 \`outbox_inspect\`, and \`outbox_run\` for registered operational workflows
 and outbox recovery.
 
@@ -103,6 +114,7 @@ apps have reimplemented by accident:
 
 | Need | Use |
 | --- | --- |${capabilityClientRow}
+| Query parameters on an HTTP contract | Pass both the Standard Schema and an explicit \`defineQueryTransport({ ... })\` to \`.query(schema, transport)\`. Use \`query.string()\`, \`query.number()\`, \`query.integer()\`, \`query.boolean()\`, \`query.dateTime()\`, \`query.date()\`, repeated scalar arrays, or one flat \`deepObject\`; never make schema coercion define the URL format. |
 | App context outside HTTP — agents, queues, scripts, backfills | \`server.createServiceContext(input)\`, or \`server.runServiceContext(input, fn)\` in one-off scripts. Never hand-assemble a context or call \`gate.attach(...)\` — the server owns gate attachment. |
 | Ports outside a request — auth callbacks, module-level helpers | \`const { ports } = await getServer()\` (dynamic \`import("@/server")\` breaks module cycles). Do not construct parallel provider clients or fall back to \`console.*\` when \`ports.logger\` exists. |
 | Routes that cannot be contracts — webhooks, third-party callbacks, streaming | \`createWebhookRoute\`, \`createPaymentWebhookRoute\`, \`createScheduleRoute\`, \`createOutboxDrainRoute\` from \`@beignet/next\`; \`server.rawRoute(...)\` for anything else. All run the hooks pipeline — never hand-enforce rate limits in a route body. |
@@ -130,6 +142,13 @@ formatting. The individual commands (\`${lint}\`, \`${cli} lint\`,
 \`${cli} doctor --strict\`, \`${test}\`, \`${typecheck}\`) still work when you
 need one check alone.
 
+Beignet's architecture lint parses TypeScript imports and re-exports,
+\`require()\`, import assignments, and literal dynamic imports, then follows
+local value imports through feature-root helpers. When lint cannot verify a
+computed module reference inside a constrained layer, use a string-literal
+specifier or move runtime loading behind an allowed boundary. Move near-miss
+feature layers to the canonical path named in the diagnostic.
+
 Before exploring unfamiliar code, run \`${cli} map\` for the human inventory
 or \`${cli} map --json --feature <name>\` for an evidence-backed graph scoped
 to one feature. The graph honors the app's complete TypeScript \`baseUrl\` and
@@ -175,7 +194,7 @@ skill-loading block.
 \`.mcp.json\` registers the app-local \`@beignet/cli\` bin at
 \`./node_modules/.bin/beignet mcp\`, which exposes app context, validation,
 generation, and operations as structured tools named exactly: \`app_map\`,
-\`explain\`, \`check\`, \`db\`, \`db_schema_sync\`, \`task_run\`,
+\`explain\`, \`check\`, \`db\`, \`db_status\`, \`db_schema_sync\`, \`task_run\`,
 \`schedule_run\`, \`outbox_inspect\`, \`outbox_run\`, \`routes\`, \`doctor\`,
 \`doctor_fix_plan\`, \`doctor_fix\`, \`lint\`, \`make\`, \`provider_add\`.
 It also publishes \`beignet://app/guidance\` and focused
@@ -190,11 +209,14 @@ relationships, conventions, findings, and suggested files for any mapped
 concept or diagnostic; its kinds match the app map. Use \`check\` after edits
 to run the complete validation loop; it returns the same versioned result as
 \`${cli} check --json\`, bounds failure output, and cancels the active package
-script when the MCP request is cancelled. It does not apply Beignet fixes, but
-app-owned scripts retain their normal side effects. Use \`db_schema_sync\` to
+script when the MCP request is cancelled. Pass \`preflightConnect: true\` to
+include migration status and dependency health checks; \`connectTimeoutMs\`
+sets their per-check timeout. It does not apply Beignet fixes, but app-owned
+scripts retain their normal side effects. Use \`db_schema_sync\` to
 preview or apply idempotent provider-table schema re-exports, then call \`db\`
 with \`generate\` and \`migrate\`; database output is bounded, commands time
-out, and cancellation stops the active process tree. Treat \`seed\` and
+out, and cancellation stops the active process tree. Use \`db_status\` for a
+read-only current, pending, or failed migration report. Treat \`seed\` and
 especially \`reset\` as app-owned mutations. Lifecycle \`dryRun\` validates
 and reports the script without executing it; it does not simulate SQL or data
 changes. Use \`task_run\` and \`schedule_run\` for registered operational

package/src/templates/base.ts

@@ -103,6 +103,7 @@ export function packageJson(ctx: TemplateContext): string {
     "db:generate": "drizzle-kit generate",
     "db:migrate": "drizzle-kit migrate",
     "db:reset": currentGeneratedPackageScripts["db:reset"],
+    "db:status": currentGeneratedPackageScripts["db:status"],
   };
 
   return json({
@@ -110,6 +111,9 @@ export function packageJson(ctx: TemplateContext): string {
     version: "0.1.0",
     private: true,
     type: "module",
+    engines: {
+      node: ">=22.12.0",
+    },
     scripts,
     intent: {
       skills: intentSkillPackages(ctx),
@@ -243,6 +247,9 @@ route groups such as \`app/(app)\` are not part of the URL.
 
 Beignet app scaffolded with \`@beignet/cli\`.
 
+Node.js 22.12 or newer is required. Bun 1.3.14 or newer is supported for
+Beignet commands.
+
 ## Getting started
 
 \`\`\`bash
@@ -254,9 +261,10 @@ ${startDatabase}## Prepare the database
 
 \`\`\`bash
 ${cli} db migrate
+${cli} db status
 \`\`\`
 
-The starter ships its initial Drizzle migration in \`drizzle/\`, so the first run only applies it. After you change \`infra/db/schema/\`, run \`${cli} db generate\` and \`${cli} db migrate\` together.
+The starter ships its initial Drizzle migration in \`drizzle/\`, so the first run only applies it. After you change \`infra/db/schema/\`, run \`${cli} db generate\` and \`${cli} db migrate\` together, then verify the target database with \`${cli} db status\`.
 
 ## Start the app
 
@@ -280,7 +288,9 @@ use cases, workflows, ports, providers, and tests connect. \`check\` runs the
 whole validation loop in one pass: \`${cli} lint\` (dependency direction),
 \`${cli} doctor --strict\` (route, OpenAPI, and resource drift), and the
 \`lint\`, \`typecheck\`, and \`test\` package scripts. Use \`${format}\` to
-apply Biome formatting.
+apply Biome formatting. Beignet lint uses the TypeScript import graph, follows
+feature-root helpers, and reports unverifiable computed module references in
+constrained layers.
 ${testingNotes}
 ## Coding agents
 
@@ -303,10 +313,11 @@ ${start}
 ${cli} make feature projects
 ${cli} db generate
 ${cli} db migrate
+${cli} db status
 ${cli} check
 \`\`\`
 
-\`make feature\` creates a contract-to-test vertical slice with Drizzle schema and repository files, so regenerate and migrate the database before running the app against the new feature.
+\`make feature\` creates a contract-to-test vertical slice with Drizzle schema and repository files, so regenerate, migrate, and verify the database before running the app against the new feature.
 Use \`${cli} make feature projects --recipe full-slice\` when you want a richer reference slice with policy, feature client helpers, workflow artifacts, events, listener registration, jobs, and outbox wiring.
 
 ## App map
@@ -352,7 +363,8 @@ ${optionalAuthRedirects}
           " db migrate` against it before starting the app."
   }
 - Size the process-wide database client for the deployment. Postgres and MySQL use the generated pool-limit environment variable; count web, worker, preview, and task processes against the database connection limit, and keep writable SQLite files on one host.
-- Run \`${cli} db generate\` and \`${cli} db migrate\` after changing the Drizzle schema.
+- Run \`${cli} db generate\`, \`${cli} db migrate\`, and \`${cli} db status\` after changing the Drizzle schema.
+- Run \`${cli} db migrate\` in one serialized migration job per environment, then \`${cli} db status\` and \`${cli} preflight --connect\` before shifting traffic. Do not migrate independently from every web replica.
 - Run \`${cli} db reset\` to rebuild a local ${
     ctx.database === "sqlite"
       ? "SQLite"
@@ -429,6 +441,7 @@ export function providersDoc(ctx: TemplateContext): string {
         "- Peer dependencies: `@upstash/ratelimit` and `@upstash/redis`",
         "- The starter wires `createUpstashRateLimitProvider()` in `server/providers.ts` and adds `rateLimit: RateLimitPort` to `AppPorts`.",
         "- `.env.example` ships dev placeholders so the app boots; set real `UPSTASH_REDIS_REST_URL` and `UPSTASH_REDIS_REST_TOKEN` values before rate limiting requests.",
+        "- Rate-limit decisions time out after 5000ms and fail closed by default. Opt into `UPSTASH_TIMEOUT_POLICY=fail-open` only when availability outweighs enforcement across this provider during an outage.",
         "",
       );
     }
@@ -510,6 +523,8 @@ export function envExample(ctx: TemplateContext): string {
       "UPSTASH_REDIS_REST_URL=https://dev-placeholder.upstash.io",
       "UPSTASH_REDIS_REST_TOKEN=dev-placeholder-change-me",
       "UPSTASH_PREFIX=beignet:ratelimit",
+      "# UPSTASH_TIMEOUT_MS=5000",
+      "# UPSTASH_TIMEOUT_POLICY=fail-closed",
       "",
     );
   }
@@ -518,6 +533,8 @@ export function envExample(ctx: TemplateContext): string {
 }
 
 const files = {
+  gitattributes: `**/drizzle/*.sql text eol=lf
+`,
   gitignore: `.next
 node_modules
 dist

package/src/templates/db/index.ts

@@ -15,6 +15,7 @@ export type DbTemplateFiles = {
   drizzleTodoRepository: string;
   dbRepositories: string;
   databaseReady: string;
+  dbMigrationStatus: string;
   dbProvider: string;
   dbReset: string;
   dbTestDatabase: string;