@beignet/cli 0.0.9 → 0.0.11

package/src/make.ts

@@ -278,6 +278,78 @@ type GeneratedFile = {
 
 type ResourcePersistence = "memory" | "drizzle";
 
+/**
+ * SQL dialect of the app database. Kept as a local literal union so the
+ * generators do not couple to the create-side option types.
+ */
+export type DatabaseName = "sqlite" | "postgres" | "mysql";
+
+/**
+ * Everything generated Drizzle code needs to target one SQL dialect: the
+ * provider subpath and database type, the drizzle-orm column builders, and
+ * whether mutations can use `.returning(...)`.
+ *
+ * Timestamps (`createdAt`/`updatedAt`/`deletedAt`) stay ISO-8601 strings in
+ * every dialect — deliberate parity with the starter so cursor pagination
+ * compares strings the same way everywhere.
+ */
+type DrizzleDialect = {
+  /** `@beignet/provider-db-drizzle` subpath the repository imports. */
+  subpath: DatabaseName;
+  /** Database type exported by the provider subpath. */
+  dbTypeName: string;
+  /** drizzle-orm column-builder module. */
+  columnModule: string;
+  /** Table factory exported by the column module. */
+  tableFunction: string;
+  /** Named imports pulled from the column module, sorted. */
+  schemaImports: readonly string[];
+  /** Whether insert/update/delete support `.returning(...)`. */
+  supportsReturning: boolean;
+  /** id and foreign-key column builder. */
+  idColumn: (columnName: string) => string;
+  /** ISO-8601 timestamp column builder. */
+  timestampColumn: (columnName: string) => string;
+  /** Integer column builder. */
+  integerColumn: (columnName: string) => string;
+};
+
+const drizzleDialects: Record<DatabaseName, DrizzleDialect> = {
+  sqlite: {
+    subpath: "sqlite",
+    dbTypeName: "DrizzleSqliteDatabase",
+    columnModule: "drizzle-orm/sqlite-core",
+    tableFunction: "sqliteTable",
+    schemaImports: ["integer", "sqliteTable", "text"],
+    supportsReturning: true,
+    idColumn: (columnName) => `text("${columnName}")`,
+    timestampColumn: (columnName) => `text("${columnName}")`,
+    integerColumn: (columnName) => `integer("${columnName}")`,
+  },
+  postgres: {
+    subpath: "postgres",
+    dbTypeName: "DrizzlePostgresDatabase",
+    columnModule: "drizzle-orm/pg-core",
+    tableFunction: "pgTable",
+    schemaImports: ["integer", "pgTable", "text"],
+    supportsReturning: true,
+    idColumn: (columnName) => `text("${columnName}")`,
+    timestampColumn: (columnName) => `text("${columnName}")`,
+    integerColumn: (columnName) => `integer("${columnName}")`,
+  },
+  mysql: {
+    subpath: "mysql",
+    dbTypeName: "DrizzleMysqlDatabase",
+    columnModule: "drizzle-orm/mysql-core",
+    tableFunction: "mysqlTable",
+    schemaImports: ["int", "mysqlTable", "text", "varchar"],
+    supportsReturning: false,
+    idColumn: (columnName) => `varchar("${columnName}", { length: 36 })`,
+    timestampColumn: (columnName) => `varchar("${columnName}", { length: 32 })`,
+    integerColumn: (columnName) => `int("${columnName}")`,
+  },
+};
+
 type IdentifierNames = {
   input: string;
   kebab: string;
@@ -437,6 +509,10 @@ async function makeResourceSlice(
   }
 
   const persistence = await detectResourcePersistence(targetDir, config);
+  const database =
+    persistence === "drizzle"
+      ? await detectResourceDatabase(targetDir, config)
+      : "sqlite";
   const generationOptions = resourceGenerationOptions(options, mode);
   const generatedFiles = resourceFiles(
     names,
@@ -444,6 +520,7 @@ async function makeResourceSlice(
     persistence,
     mode,
     generationOptions,
+    database,
   );
   const plannedFiles = await planGeneratedFiles(targetDir, generatedFiles, {
     force: Boolean(options.force),
@@ -4071,6 +4148,7 @@ function resourceFiles(
     events: false,
     softDelete: false,
   },
+  database: DatabaseName = "sqlite",
 ): GeneratedFile[] {
   const useCaseDir = resourceUseCaseDir(names, config);
   const infraDir = infrastructureDir(config);
@@ -4155,14 +4233,15 @@ function resourceFiles(
   ];
 
   if (persistence === "drizzle") {
+    const dialect = drizzleDialects[database];
     files.push(
       {
         path: drizzleResourceSchemaFilePath(names, config),
-        content: drizzleSchemaFile(names, options),
+        content: drizzleSchemaFile(names, options, dialect),
       },
       {
         path: drizzleResourceRepositoryFilePath(names, config),
-        content: drizzleRepositoryFile(names, config, mode, options),
+        content: drizzleRepositoryFile(names, config, mode, options, dialect),
       },
     );
   }
@@ -4472,6 +4551,51 @@ async function detectResourcePersistence(
     : "memory";
 }
 
+const databaseNames = ["sqlite", "postgres", "mysql"] as const;
+
+/**
+ * Detect the SQL dialect of a Drizzle app from its generated wiring.
+ *
+ * Precedence:
+ * 1. The provider import in the Drizzle repositories file
+ *    (`@beignet/provider-db-drizzle/<dialect>`), resolved through the
+ *    configured infrastructure paths so custom layouts keep working.
+ * 2. The provider registration tokens in `server/providers.ts`
+ *    (`drizzle<Dialect>Provider` / `createDrizzle<Dialect>Provider`).
+ * 3. `"sqlite"`, the starter default.
+ *
+ * Self-healing by design: there is no config field to drift, the detector
+ * reads the same files the app boots from.
+ */
+export async function detectResourceDatabase(
+  targetDir: string,
+  config: ResolvedBeignetConfig,
+): Promise<DatabaseName> {
+  const repositories = await readOptionalFile(
+    path.join(targetDir, drizzleRepositoriesPath(config)),
+  );
+  const providerImport = repositories?.match(
+    /from\s+["']@beignet\/provider-db-drizzle\/(sqlite|postgres|mysql)["']/,
+  );
+  if (providerImport) return providerImport[1] as DatabaseName;
+
+  const providers = await readOptionalFile(
+    path.join(targetDir, providersFilePath(config)),
+  );
+  if (providers !== undefined) {
+    for (const database of databaseNames) {
+      const dialectPascal =
+        database.charAt(0).toUpperCase() + database.slice(1);
+      const tokens = new RegExp(
+        `\\b(?:drizzle${dialectPascal}Provider|createDrizzle${dialectPascal}Provider)\\b`,
+      );
+      if (tokens.test(providers)) return database;
+    }
+  }
+
+  return "sqlite";
+}
+
 function resourceFeatureDir(
   names: ResourceNames,
   config: ResolvedBeignetConfig,
@@ -5826,16 +5950,17 @@ ${mode === "resource" ? `		async findById(id: string${options.tenant ? ", filter
 function drizzleSchemaFile(
   names: ResourceNames,
   options: ResourceGenerationOptions,
+  dialect: DrizzleDialect,
 ): string {
-  return `import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
-
-export const ${names.pluralCamel} = sqliteTable("${names.pluralKebab.replaceAll("-", "_")}", {
-	id: text("id").primaryKey(),
-${options.tenant ? `\ttenantId: text("tenant_id").notNull(),\n` : ""}	name: text("name").notNull(),
-	version: integer("version").notNull(),
-	createdAt: text("created_at").notNull(),
-	updatedAt: text("updated_at").notNull(),
-${options.softDelete ? `\tdeletedAt: text("deleted_at"),\n` : ""}});
+  return `import { ${dialect.schemaImports.join(", ")} } from "${dialect.columnModule}";
+
+export const ${names.pluralCamel} = ${dialect.tableFunction}("${names.pluralKebab.replaceAll("-", "_")}", {
+	id: ${dialect.idColumn("id")}.primaryKey(),
+${options.tenant ? `\ttenantId: ${dialect.idColumn("tenant_id")}.notNull(),\n` : ""}	name: text("name").notNull(),
+	version: ${dialect.integerColumn("version")}.notNull(),
+	createdAt: ${dialect.timestampColumn("created_at")}.notNull(),
+	updatedAt: ${dialect.timestampColumn("updated_at")}.notNull(),
+${options.softDelete ? `\tdeletedAt: ${dialect.timestampColumn("deleted_at")},\n` : ""}});
 `;
 }
 
@@ -5861,6 +5986,7 @@ function drizzleRepositoryFile(
   config: ResolvedBeignetConfig,
   mode: ResourceGenerationMode,
   options: ResourceGenerationOptions,
+  dialect: DrizzleDialect,
 ): string {
   const repositoryPortPath = resourcePortFilePath(names, config);
   const schemaPath = drizzleSchemaIndexPath(config);
@@ -5895,10 +6021,134 @@ function drizzleRepositoryFile(
     "sql",
     "type SQL",
   ].filter((name): name is string => Boolean(name));
+  // After a version-guarded update succeeds, re-select by identity only —
+  // matching what `.returning()` yields on the dialects that support it.
+  const updateReselectWhere = options.tenant
+    ? `and(eq(schema.${names.pluralCamel}.id, input.id), eq(schema.${names.pluralCamel}.tenantId, input.tenantId))`
+    : `eq(schema.${names.pluralCamel}.id, input.id)`;
+  // drizzle-orm/mysql2 has no `.returning(...)`; mutations resolve to a
+  // `[ResultSetHeader, FieldPacket[]]` tuple typed as `unknown` through the
+  // generic database seam, so generated MySQL code reads affectedRows
+  // defensively and re-selects rows it needs back.
+  const affectedRowsHelper =
+    mode === "resource" && !dialect.supportsReturning
+      ? `
+// drizzle-orm/mysql2 mutations resolve to [ResultSetHeader, FieldPacket[]],
+// typed as unknown through the generic database seam, so read affectedRows
+// defensively.
+function affectedRows(result: unknown): number {
+	const head: unknown = Array.isArray(result) ? result[0] : undefined;
+	if (head === null || typeof head !== "object") return 0;
+	return "affectedRows" in head && typeof head.affectedRows === "number"
+		? head.affectedRows
+		: 0;
+}
+`
+      : "";
+  const createMethod = dialect.supportsReturning
+    ? `		async create(input) {
+			const now = new Date().toISOString();
+			const [row] = await db
+				.insert(schema.${names.pluralCamel})
+				.values({
+					id: crypto.randomUUID(),
+${options.tenant ? `\t\t\t\t\ttenantId: input.tenantId,\n` : ""}					name: input.name,
+					version: 1,
+					createdAt: now,
+					updatedAt: now,
+				})
+				.returning();
+
+			if (!row) {
+				throw new Error("Failed to create ${names.singularKebab}.");
+			}
+
+			return to${names.singularPascal}(row);
+		},
+`
+    : `		async create(input) {
+			const now = new Date().toISOString();
+			const ${names.singularCamel}: ${names.singularPascal} = {
+				id: crypto.randomUUID(),
+${options.tenant ? `\t\t\t\ttenantId: input.tenantId,\n` : ""}				name: input.name,
+				version: 1,
+				createdAt: now,
+				updatedAt: now,
+			};
+			await db.insert(schema.${names.pluralCamel}).values(${names.singularCamel});
+
+			return ${names.singularCamel};
+		},
+`;
+  const resourceMethods =
+    mode !== "resource"
+      ? ""
+      : dialect.supportsReturning
+        ? `		async findById(id: string${options.tenant ? ", filter" : ""}) {
+			const [row] = await db
+				.select()
+				.from(schema.${names.pluralCamel})
+				.where(${findWhere})
+				.limit(1);
+
+			return row ? to${names.singularPascal}(row) : null;
+		},
+		async update(input) {
+			const [row] = await db
+				.update(schema.${names.pluralCamel})
+				.set({
+					name: input.name,
+					version: input.version + 1,
+					updatedAt: new Date().toISOString(),
+				})
+				.where(${updateWhere})
+				.returning();
+
+			return row ? to${names.singularPascal}(row) : null;
+		},
+		async delete(id: string${options.tenant ? ", filter" : ""}) {
+${options.softDelete ? `\t\t\tconst now = new Date().toISOString();\n\t\t\tconst rows = await db\n\t\t\t\t.update(schema.${names.pluralCamel})\n\t\t\t\t.set({ deletedAt: now, updatedAt: now })\n\t\t\t\t.where(${deleteWhere})\n\t\t\t\t.returning({ id: schema.${names.pluralCamel}.id });\n` : `\t\t\tconst rows = await db\n\t\t\t\t.delete(schema.${names.pluralCamel})\n\t\t\t\t.where(${deleteWhere})\n\t\t\t\t.returning({ id: schema.${names.pluralCamel}.id });\n`}
+			return rows.length > 0;
+		},
+`
+        : `		async findById(id: string${options.tenant ? ", filter" : ""}) {
+			const [row] = await db
+				.select()
+				.from(schema.${names.pluralCamel})
+				.where(${findWhere})
+				.limit(1);
+
+			return row ? to${names.singularPascal}(row) : null;
+		},
+		async update(input) {
+			const result = await db
+				.update(schema.${names.pluralCamel})
+				.set({
+					name: input.name,
+					version: input.version + 1,
+					updatedAt: new Date().toISOString(),
+				})
+				.where(${updateWhere});
+
+			if (affectedRows(result) === 0) return null;
+
+			const [row] = await db
+				.select()
+				.from(schema.${names.pluralCamel})
+				.where(${updateReselectWhere})
+				.limit(1);
+
+			return row ? to${names.singularPascal}(row) : null;
+		},
+		async delete(id: string${options.tenant ? ", filter" : ""}) {
+${options.softDelete ? `\t\t\tconst now = new Date().toISOString();\n\t\t\tconst result = await db\n\t\t\t\t.update(schema.${names.pluralCamel})\n\t\t\t\t.set({ deletedAt: now, updatedAt: now })\n\t\t\t\t.where(${deleteWhere});\n` : `\t\t\tconst result = await db\n\t\t\t\t.delete(schema.${names.pluralCamel})\n\t\t\t\t.where(${deleteWhere});\n`}
+			return affectedRows(result) > 0;
+		},
+`;
 
   return `import type { beignetServerOnly } from "@beignet/core/server-only";
 import { cursorPageResult } from "@beignet/core/pagination";
-import type { DrizzleSqliteDatabase } from "@beignet/provider-db-drizzle/sqlite";
+import type { ${dialect.dbTypeName} } from "@beignet/provider-db-drizzle/${dialect.subpath}";
 import { ${drizzleImports.join(", ")} } from "drizzle-orm";
 import type { ${names.singularPascal}Repository } from "${aliasModule(repositoryPortPath)}";
 import { encode${names.singularPascal}Cursor } from "${aliasModule(resourceSchemaFilePath(names, config))}";
@@ -5919,7 +6169,7 @@ ${options.tenant ? `\t\ttenantId: row.tenantId,\n` : ""}		name: row.name,
 		updatedAt: row.updatedAt,
 	};
 }
-
+${affectedRowsHelper}
 type List${names.pluralPascal}Query = Parameters<${names.singularPascal}Repository["list"]>[0];
 
 function ${names.singularCamel}SortColumn(query: List${names.pluralPascal}Query) {
@@ -5978,7 +6228,7 @@ function cursorFor${names.singularPascal}(
 }
 
 export function createDrizzle${names.singularPascal}Repository(
-	db: DrizzleSqliteDatabase<typeof schema>,
+	db: ${dialect.dbTypeName}<typeof schema>,
 ): ${names.singularPascal}Repository {
 	return {
 		async list(query) {
@@ -6001,26 +6251,7 @@ export function createDrizzle${names.singularPascal}Repository(
 				nextCursor,
 			);
 		},
-		async create(input) {
-			const now = new Date().toISOString();
-			const [row] = await db
-				.insert(schema.${names.pluralCamel})
-				.values({
-					id: crypto.randomUUID(),
-${options.tenant ? `\t\t\t\t\ttenantId: input.tenantId,\n` : ""}					name: input.name,
-					version: 1,
-					createdAt: now,
-					updatedAt: now,
-				})
-				.returning();
-
-			if (!row) {
-				throw new Error("Failed to create ${names.singularKebab}.");
-			}
-
-			return to${names.singularPascal}(row);
-		},
-${mode === "resource" ? `		async findById(id: string${options.tenant ? ", filter" : ""}) {\n			const [row] = await db\n				.select()\n				.from(schema.${names.pluralCamel})\n				.where(${findWhere})\n				.limit(1);\n\n			return row ? to${names.singularPascal}(row) : null;\n		},\n		async update(input) {\n			const [row] = await db\n				.update(schema.${names.pluralCamel})\n				.set({\n					name: input.name,\n					version: input.version + 1,\n					updatedAt: new Date().toISOString(),\n				})\n				.where(${updateWhere})\n				.returning();\n\n			return row ? to${names.singularPascal}(row) : null;\n		},\n		async delete(id: string${options.tenant ? ", filter" : ""}) {\n${options.softDelete ? `\t\t\tconst now = new Date().toISOString();\n\t\t\tconst rows = await db\n\t\t\t\t.update(schema.${names.pluralCamel})\n\t\t\t\t.set({ deletedAt: now, updatedAt: now })\n\t\t\t\t.where(${deleteWhere})\n\t\t\t\t.returning({ id: schema.${names.pluralCamel}.id });\n` : `\t\t\tconst rows = await db\n\t\t\t\t.delete(schema.${names.pluralCamel})\n\t\t\t\t.where(${deleteWhere})\n\t\t\t\t.returning({ id: schema.${names.pluralCamel}.id });\n`}\n			return rows.length > 0;\n		},\n` : ""}
+${createMethod}${resourceMethods}
 	};
 }
 `;