@beignet/cli 0.0.7 → 0.0.9

package/src/registry-edits.ts

@@ -0,0 +1,352 @@
+/**
+ * Shared string-edit helpers for registry files.
+ *
+ * `beignet make` generators and `beignet doctor --fix` both append entries to
+ * app-owned registry files such as `server/schedules.ts`, `server/tasks.ts`,
+ * and `server/outbox.ts`. Keeping the import insertion, array append, and
+ * membership primitives in one module keeps both write paths byte-compatible.
+ */
+
+/**
+ * Source slice for an initializer expression, with absolute offsets.
+ */
+export type InitializerInfo = {
+  text: string;
+  start: number;
+  end: number;
+};
+
+/**
+ * Result of appending an entry to a named registry.
+ *
+ * `missing` means the registry anchor could not be found or is not an array
+ * literal; callers should bail without writing.
+ */
+export type AppendResult =
+  | { kind: "updated"; source: string }
+  | { kind: "unchanged" }
+  | { kind: "missing" };
+
+/**
+ * Find the index of the delimiter closing the one at `openIndex`, skipping
+ * string literals.
+ */
+export function matchingDelimiterIndex(
+  source: string,
+  openIndex: number,
+  open: string,
+  close: string,
+): number {
+  let depth = 0;
+  let inString: string | undefined;
+  let escaped = false;
+
+  for (let index = openIndex; index < source.length; index++) {
+    const char = source[index];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === inString) {
+        inString = undefined;
+      }
+      continue;
+    }
+
+    if (char === '"' || char === "'" || char === "`") {
+      inString = char;
+      continue;
+    }
+
+    if (char === open) {
+      depth++;
+      continue;
+    }
+
+    if (char === close) {
+      depth--;
+      if (depth === 0) return index;
+    }
+  }
+
+  return -1;
+}
+
+/**
+ * Insert a line directly after the last top-level import statement.
+ */
+export function insertAfterImports(source: string, line: string): string {
+  const lines = source.split("\n");
+  let lastImportIndex = -1;
+
+  for (let index = 0; index < lines.length; index++) {
+    if (lines[index].startsWith("import ")) {
+      lastImportIndex = index;
+    }
+  }
+
+  if (lastImportIndex === -1) {
+    return `${line}\n${source}`;
+  }
+
+  lines.splice(lastImportIndex + 1, 0, line);
+  return lines.join("\n");
+}
+
+/**
+ * Collect every identifier referenced inside an array (or object) expression.
+ */
+export function identifiersFromArrayExpression(
+  expression: string,
+): Set<string> {
+  const withoutBrackets = expression.replace(/^\[/, "").replace(/\]$/, "");
+
+  return new Set(
+    Array.from(
+      withoutBrackets.matchAll(/\b[A-Za-z_$][\w$]*\b/g),
+      ([name]) => name,
+    ),
+  );
+}
+
+/**
+ * Append entries to an array literal, preserving single-line and multiline
+ * formatting plus trailing commas.
+ */
+export function appendToArrayExpression(
+  expression: string,
+  names: string[],
+): string {
+  const closingBracket = /\]\s*$/.exec(expression);
+  if (!closingBracket) return expression;
+
+  const beforeClosingBracket = expression.slice(0, closingBracket.index);
+  const closingBracketText = expression.slice(closingBracket.index);
+  const inner = beforeClosingBracket.replace(/^\[/, "");
+  if (!inner.trim()) return `[${names.join(", ")}]`;
+
+  if (!expression.includes("\n")) {
+    const separator = /,\s*$/.test(inner) ? " " : ", ";
+    return `${beforeClosingBracket}${separator}${names.join(", ")}${closingBracketText}`;
+  }
+
+  const itemIndent =
+    inner
+      .split("\n")
+      .find((line) => line.trim())
+      ?.match(/^[\t ]*/)?.[0] ?? "\t";
+  const closingIndent = inner.match(/\n([\t ]*)$/)?.[1] ?? "";
+  const trimmedBeforeClosingBracket = beforeClosingBracket.replace(/\s*$/, "");
+  const appendedNames = names.join(`,\n${itemIndent}`);
+
+  if (/,\s*$/.test(inner)) {
+    return `${trimmedBeforeClosingBracket}\n${itemIndent}${appendedNames},\n${closingIndent}${closingBracketText}`;
+  }
+
+  return `${trimmedBeforeClosingBracket},\n${itemIndent}${appendedNames}${closingBracketText}`;
+}
+
+/**
+ * Locate the array literal initializing `const <constName> = ...`.
+ *
+ * Wrapping calls such as `defineTasks([...])` are tolerated because the first
+ * `[` after the assignment is used.
+ */
+export function arrayInitializerInfo(
+  source: string,
+  constName: string,
+): InitializerInfo | undefined {
+  const match = new RegExp(`\\bconst\\s+${constName}\\s*=`).exec(source);
+  if (!match) return undefined;
+
+  const openBracket = source.indexOf("[", match.index);
+  if (openBracket === -1) return undefined;
+
+  const closeBracket = matchingDelimiterIndex(source, openBracket, "[", "]");
+  if (closeBracket === -1) return undefined;
+
+  return {
+    text: source.slice(openBracket, closeBracket + 1),
+    start: openBracket,
+    end: closeBracket + 1,
+  };
+}
+
+/**
+ * Append `entry` to the array initializing `const <constName> = [...]` and
+ * insert `importLine` after the imports when it is not already present.
+ *
+ * Generalizes the `server/schedules.ts` and `server/tasks.ts` registry update
+ * used by `beignet make`. Returns `missing` without touching the source when
+ * the array cannot be found, so callers never partially write.
+ */
+export function appendToNamedArray(
+  source: string,
+  constName: string,
+  entry: string,
+  importLine?: string,
+): AppendResult {
+  const registry = arrayInitializerInfo(source, constName);
+  if (!registry) return { kind: "missing" };
+
+  return appendEntry(source, registry, entry, importLine, (next) =>
+    arrayInitializerInfo(next, constName),
+  );
+}
+
+/**
+ * Locate the `events` or `jobs` value inside `defineOutboxRegistry({...})`.
+ */
+export function outboxRegistryValueInfo(
+  source: string,
+  property: "events" | "jobs",
+): InitializerInfo | undefined {
+  const call = /\bdefineOutboxRegistry\s*(?:<[^>]*>\s*)?\(/.exec(source);
+  if (!call) return undefined;
+
+  const openBrace = source.indexOf("{", call.index);
+  if (openBrace === -1) return undefined;
+
+  const closeBrace = matchingDelimiterIndex(source, openBrace, "{", "}");
+  if (closeBrace === -1) return undefined;
+
+  const objectText = source.slice(openBrace, closeBrace + 1);
+  const propertyMatch = new RegExp(`\\b${property}\\s*:`).exec(objectText);
+  if (!propertyMatch) return undefined;
+
+  const valueStart = openBrace + propertyMatch.index + propertyMatch[0].length;
+  const value = topLevelValueSlice(source, valueStart, closeBrace);
+  if (!value) return undefined;
+
+  return value;
+}
+
+/**
+ * Append `entry` to the `events` or `jobs` array of
+ * `defineOutboxRegistry({...})` and insert `importLine` when needed.
+ *
+ * Returns `missing` without touching the source when the registry call or
+ * property is absent, or when the property value is not an array literal.
+ */
+export function appendToOutboxRegistryArray(
+  source: string,
+  property: "events" | "jobs",
+  entry: string,
+  importLine?: string,
+): AppendResult {
+  const value = outboxRegistryValueInfo(source, property);
+  if (!value) return { kind: "missing" };
+
+  const entryName = entryIdentifier(entry);
+  if (identifiersFromArrayExpression(value.text).has(entryName)) {
+    return appendEntry(source, value, entry, importLine, () => undefined, {
+      alreadyListed: true,
+    });
+  }
+
+  if (!value.text.startsWith("[")) return { kind: "missing" };
+
+  return appendEntry(source, value, entry, importLine, (next) =>
+    outboxRegistryValueInfo(next, property),
+  );
+}
+
+function entryIdentifier(entry: string): string {
+  return entry.replace(/^\.{3}/, "").trim();
+}
+
+function appendEntry(
+  source: string,
+  info: InitializerInfo,
+  entry: string,
+  importLine: string | undefined,
+  relocate: (next: string) => InitializerInfo | undefined,
+  options: { alreadyListed?: boolean } = {},
+): AppendResult {
+  const alreadyListed =
+    options.alreadyListed ??
+    identifiersFromArrayExpression(info.text).has(entryIdentifier(entry));
+  let next = source;
+
+  if (importLine && !next.includes(importLine)) {
+    next = insertAfterImports(next, importLine);
+  }
+
+  if (!alreadyListed) {
+    const target = next === source ? info : relocate(next);
+    if (!target) return { kind: "missing" };
+    const nextArray = appendToArrayExpression(target.text, [entry]);
+    next = `${next.slice(0, target.start)}${nextArray}${next.slice(target.end)}`;
+  }
+
+  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;
+  let inString: string | undefined;
+  let escaped = false;
+
+  for (let index = start; index <= hardEnd; index++) {
+    const char = source[index];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === inString) {
+        inString = undefined;
+      }
+      continue;
+    }
+
+    if (char === '"' || char === "'" || char === "`") {
+      inString = char;
+      continue;
+    }
+
+    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/base.ts

@@ -15,7 +15,7 @@ export function packageJson(ctx: TemplateContext): string {
     "@beignet/devtools": ctx.beignetVersion,
     "@beignet/next": ctx.beignetVersion,
     "@beignet/provider-auth-better-auth": ctx.beignetVersion,
-    "@beignet/provider-drizzle-turso": ctx.beignetVersion,
+    "@beignet/provider-db-drizzle": ctx.beignetVersion,
     "@beignet/provider-logger-pino": ctx.beignetVersion,
     "@libsql/client": externalVersions.libsqlClient,
     "better-auth": externalVersions.betterAuth,
@@ -214,7 +214,7 @@ ${cli} doctor
 ${shellMap}
 ## Before deploying
 
-- Create a Turso database or keep \`TURSO_DB_URL=file:local.db\` for local libSQL development.
+- Keep \`SQLITE_DB_URL=file:local.db\` for local libSQL development or point it at a hosted libSQL database such as Turso.
 - Run \`${cli} db generate\` and \`${cli} db migrate\` after changing the Drizzle schema.
 - Run \`${cli} db reset\` to rebuild a local SQLite database from the checked-in migrations.
 - Remove \`DEVTOOLS_ENABLED=true\` in production unless you add authentication and stricter redaction.
@@ -288,8 +288,8 @@ export function envExample(ctx: TemplateContext): string {
     `LOG_SERVICE=${ctx.name}`,
     "",
     "# Use file:local.db for local libSQL or libsql://... for Turso cloud.",
-    "TURSO_DB_URL=file:local.db",
-    "# TURSO_DB_AUTH_TOKEN=",
+    "SQLITE_DB_URL=file:local.db",
+    "# SQLITE_DB_AUTH_TOKEN=",
     "",
     "BETTER_AUTH_SECRET=local-dev-better-auth-secret-change-me",
     "BETTER_AUTH_URL=http://localhost:3000",

package/src/templates/db.ts

@@ -15,8 +15,8 @@ const files = {
 	out: "./drizzle",
 	dialect: "sqlite",
 	dbCredentials: {
-		url: process.env.TURSO_DB_URL ?? "file:local.db",
-		authToken: process.env.TURSO_DB_AUTH_TOKEN,
+		url: process.env.SQLITE_DB_URL ?? "file:local.db",
+		authToken: process.env.SQLITE_DB_AUTH_TOKEN,
 	},
 };
 `,
@@ -123,7 +123,7 @@ export const idempotencyRecords = sqliteTable(
 `,
   drizzleTodoRepository: `import type { beignetServerOnly } from "@beignet/core/server-only";
 import { offsetPageResult } from "@beignet/core/pagination";
-import type { DrizzleTursoDatabase } from "@beignet/provider-drizzle-turso";
+import type { DrizzleSqliteDatabase } from "@beignet/provider-db-drizzle/sqlite";
 import { count, desc, eq } from "drizzle-orm";
 import type {
 	NewTodo,
@@ -146,7 +146,7 @@ function toTodo(row: TodoRow): Todo {
 }
 
 export function createDrizzleTodoRepository(
-	db: DrizzleTursoDatabase<typeof schema>,
+	db: DrizzleSqliteDatabase<typeof schema>,
 ): TodoRepository {
 	return {
 		async list(userId, page) {
@@ -208,13 +208,13 @@ export function createDrizzleTodoRepository(
 	};
 }
 `,
-  dbRepositories: `import type { DrizzleTursoDatabase } from "@beignet/provider-drizzle-turso";
+  dbRepositories: `import type { DrizzleSqliteDatabase } from "@beignet/provider-db-drizzle/sqlite";
 import { createDrizzleTodoRepository } from "@/infra/todos/drizzle-todo-repository";
 import type { AppTransactionPorts } from "@/ports";
 import * as schema from "./schema";
 
 export function createRepositories(
-	db: DrizzleTursoDatabase<typeof schema>,
+	db: DrizzleSqliteDatabase<typeof schema>,
 ): Omit<AppTransactionPorts, "idempotency"> {
 	return {
 		todos: createDrizzleTodoRepository(db),
@@ -265,10 +265,10 @@ async function prepare(client: Client): Promise<void> {
   dbProvider: `import type { beignetServerOnly } from "@beignet/core/server-only";
 import { createProvider } from "@beignet/core/providers";
 import {
-	createDrizzleTursoIdempotencyPort,
-	createDrizzleTursoUnitOfWork,
+	createDrizzleSqliteIdempotencyPort,
+	createDrizzleSqliteUnitOfWork,
 	type DbPort,
-} from "@beignet/provider-drizzle-turso";
+} from "@beignet/provider-db-drizzle/sqlite";
 import type { AppPorts } from "@/ports";
 import { ensureDatabaseReady } from "./database-ready";
 import { createRepositories } from "./repositories";
@@ -283,21 +283,21 @@ export const starterDatabaseProvider = createProvider<{
 		const dbPort = ports.db;
 		if (!dbPort) {
 			throw new Error(
-				"starterDatabaseProvider requires a db port. Register createDrizzleTursoProvider({ schema }) before it.",
+				"starterDatabaseProvider requires a db port. Register createDrizzleSqliteProvider({ schema }) before it.",
 			);
 		}
 
 		const repositories = createRepositories(dbPort.db);
-		const idempotency = createDrizzleTursoIdempotencyPort(dbPort.db);
+		const idempotency = createDrizzleSqliteIdempotencyPort(dbPort.db);
 
 		const providedPorts: Pick<AppPorts, "idempotency" | "todos" | "uow"> = {
 			...repositories,
 			idempotency,
-			uow: createDrizzleTursoUnitOfWork({
+			uow: createDrizzleSqliteUnitOfWork({
 				db: dbPort.db,
 				createTransactionPorts: (tx) => ({
 					...createRepositories(tx),
-					idempotency: createDrizzleTursoIdempotencyPort(tx),
+					idempotency: createDrizzleSqliteIdempotencyPort(tx),
 				}),
 			}),
 		};
@@ -317,7 +317,7 @@ import { migrate } from "drizzle-orm/libsql/migrator";
 import { env } from "@/lib/env";
 
 if (
-	!env.TURSO_DB_URL.startsWith("file:") &&
+	!env.SQLITE_DB_URL.startsWith("file:") &&
 	process.env.BEIGNET_ALLOW_DATABASE_RESET !== "true"
 ) {
 	throw new Error(
@@ -336,8 +336,8 @@ const tables = [
 ] as const;
 
 const client = createClient({
-	url: env.TURSO_DB_URL,
-	authToken: env.TURSO_DB_AUTH_TOKEN,
+	url: env.SQLITE_DB_URL,
+	authToken: env.SQLITE_DB_AUTH_TOKEN,
 });
 
 try {

package/src/templates/server.ts

@@ -5,7 +5,7 @@ export function serverProviders(ctx: TemplateContext): string {
     'import type { beignetServerOnly } from "@beignet/core/server-only";',
     'import { createDevtoolsProvider } from "@beignet/devtools";',
     'import { createAuthBetterAuthProvider } from "@beignet/provider-auth-better-auth";',
-    'import { createDrizzleTursoProvider } from "@beignet/provider-drizzle-turso";',
+    'import { createDrizzleSqliteProvider } from "@beignet/provider-db-drizzle/sqlite";',
     hasIntegration(ctx, "inngest")
       ? 'import { inngestProvider } from "@beignet/provider-inngest";'
       : undefined,
@@ -26,7 +26,7 @@ export function serverProviders(ctx: TemplateContext): string {
     "\tcreateDevtoolsProvider(),",
     "\tcreateAuthBetterAuthProvider<AuthUser, AuthSessionMetadata>(auth),",
     "\tloggerPinoProvider,",
-    "\tdrizzleTursoProvider,",
+    "\tdrizzleSqliteProvider,",
     "\tstarterDatabaseProvider,",
     hasIntegration(ctx, "inngest") ? "\tinngestProvider," : undefined,
     hasIntegration(ctx, "resend") ? "\tmailResendProvider," : undefined,
@@ -37,7 +37,7 @@ export function serverProviders(ctx: TemplateContext): string {
 
   return `${imports.join("\n")}
 
-const drizzleTursoProvider = createDrizzleTursoProvider({ schema });
+const drizzleSqliteProvider = createDrizzleSqliteProvider({ schema });
 
 export const providers = [
 ${entries.join("\n")}
@@ -151,8 +151,8 @@ export const env = createEnv({
 			.default("local-dev-better-auth-secret-change-me"),
 		BETTER_AUTH_URL: z.string().url().default("http://localhost:3000"),
 		BETTER_AUTH_TRUSTED_ORIGINS: z.string().optional(),
-		TURSO_DB_URL: z.string().default("file:local.db"),
-		TURSO_DB_AUTH_TOKEN: z.string().optional(),
+		SQLITE_DB_URL: z.string().default("file:local.db"),
+		SQLITE_DB_AUTH_TOKEN: z.string().optional(),
 		LOG_LEVEL: z
 			.enum(["trace", "debug", "info", "warn", "error", "fatal"])
 			.default("info"),
@@ -344,9 +344,9 @@ export const server = await createNextServer({
 	ports: appPorts,
 	providers,
 	providerConfig: {
-		"drizzle-turso": {
-			DB_URL: env.TURSO_DB_URL,
-			DB_AUTH_TOKEN: env.TURSO_DB_AUTH_TOKEN,
+		"drizzle-sqlite": {
+			DB_URL: env.SQLITE_DB_URL,
+			DB_AUTH_TOKEN: env.SQLITE_DB_AUTH_TOKEN,
 		},
 	},
 	hooks: [createIdempotencyHooks<AppContext>()],
@@ -428,8 +428,8 @@ import * as schema from "@/infra/db/schema";
 import { env } from "@/lib/env";
 
 const client = createClient({
-	url: env.TURSO_DB_URL,
-	authToken: env.TURSO_DB_AUTH_TOKEN,
+	url: env.SQLITE_DB_URL,
+	authToken: env.SQLITE_DB_AUTH_TOKEN,
 });
 
 // Auth routes can be the first thing to touch the database, before any