futonic 0.1.0

package/dist/chunk-5va59f7m.js

@@ -0,0 +1,20 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+export { __toESM, __require };

package/dist/chunk-6w1vqkpr.js

@@ -0,0 +1,87 @@
+import"./chunk-5va59f7m.js";
+
+// src/cli/generators/kysely.ts
+var generateKyselySchema = async ({
+  tables,
+  provider,
+  file
+}) => {
+  const statements = [];
+  for (const [, table] of tables) {
+    statements.push(tableToSQL(table, provider));
+  }
+  const code = statements.join(`
+
+`);
+  return {
+    code: code.trim() || "",
+    fileName: file || `./futonic_migrations/${new Date().toISOString().replace(/:/g, "-")}.sql`
+  };
+};
+function tableToSQL(table, provider = "pg") {
+  const columns = [];
+  for (const [fieldName, field] of Object.entries(table.fields)) {
+    columns.push(`  ${fieldName} ${fieldToSQLType(field, provider)}`);
+  }
+  for (const [fieldName, field] of Object.entries(table.fields)) {
+    if (field.references) {
+      const onDelete = field.references.onDelete ?? "restrict";
+      const action = onDelete === "set-null" ? "SET NULL" : onDelete.toUpperCase();
+      columns.push(`  FOREIGN KEY (${fieldName}) REFERENCES ${field.references.model}(${field.references.field}) ON DELETE ${action}`);
+    }
+  }
+  return `CREATE TABLE IF NOT EXISTS ${table.prefixedName} (
+${columns.join(`,
+`)}
+);`;
+}
+function fieldToSQLType(field, provider) {
+  let type;
+  switch (field.type) {
+    case "string":
+      if (provider === "mysql" && (field.unique || field.references)) {
+        type = "VARCHAR(255)";
+      } else {
+        type = "TEXT";
+      }
+      break;
+    case "number":
+      type = provider === "mysql" ? "INT" : "INTEGER";
+      break;
+    case "boolean":
+      type = provider === "sqlite" ? "INTEGER" : "BOOLEAN";
+      break;
+    case "date":
+      type = provider === "sqlite" ? "INTEGER" : "TIMESTAMP";
+      break;
+    case "json":
+      if (provider === "pg")
+        type = "JSONB";
+      else if (provider === "mysql")
+        type = "JSON";
+      else
+        type = "TEXT";
+      break;
+    default:
+      type = "TEXT";
+  }
+  const parts = [type];
+  if (field.primaryKey)
+    parts.push("PRIMARY KEY");
+  if (field.required)
+    parts.push("NOT NULL");
+  if (field.unique)
+    parts.push("UNIQUE");
+  if (field.defaultValue !== undefined) {
+    if (typeof field.defaultValue === "string") {
+      parts.push(`DEFAULT '${field.defaultValue}'`);
+    } else {
+      parts.push(`DEFAULT ${field.defaultValue}`);
+    }
+  }
+  return parts.join(" ");
+}
+export {
+  tableToSQL,
+  generateKyselySchema
+};

package/dist/chunk-j2yky04y.js

@@ -0,0 +1,130 @@
+import {
+  __require,
+  __toESM
+} from "./chunk-5va59f7m.js";
+
+// src/cli/generators/prisma.ts
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+var generatePrismaSchema = async ({
+  tables,
+  provider: dbProvider,
+  file
+}) => {
+  const provider = dbProvider === "pg" ? "postgresql" : dbProvider === "mysql" ? "mysql" : "sqlite";
+  const filePath = file || "./prisma/schema.prisma";
+  const schemaExists = existsSync(path.resolve(filePath));
+  let produceSchema;
+  try {
+    ({ produceSchema } = await import("@mrleebo/prisma-ast"));
+  } catch {
+    throw new Error("@mrleebo/prisma-ast is required for Prisma schema generation. Install it with: npm install @mrleebo/prisma-ast");
+  }
+  let schemaPrisma = "";
+  if (schemaExists) {
+    schemaPrisma = await readFile(path.resolve(filePath), "utf-8");
+  } else {
+    schemaPrisma = getNewPrisma(provider);
+  }
+  const schema = produceSchema(schemaPrisma, (builder) => {
+    for (const [, table] of tables) {
+      const modelName = toPascalCase(table.prefixedName);
+      const prismaModel = builder.findByType("model", {
+        name: modelName
+      });
+      if (!prismaModel) {
+        builder.model(modelName).field("id", "String").attribute("id");
+      }
+      for (const [fieldName, field] of Object.entries(table.fields)) {
+        if (fieldName === "id")
+          continue;
+        if (prismaModel) {
+          const existing = builder.findByType("field", {
+            name: fieldName,
+            within: prismaModel.properties
+          });
+          if (existing)
+            continue;
+        }
+        const prismaType = getPrismaType(field, provider);
+        const fieldBuilder = builder.model(modelName).field(fieldName, prismaType);
+        if (field.primaryKey) {
+          fieldBuilder.attribute("id");
+        }
+        if (field.unique) {
+          builder.model(modelName).blockAttribute(`unique([${fieldName}])`);
+        }
+        if (field.defaultValue !== undefined && field.defaultValue !== null) {
+          if (typeof field.defaultValue === "string") {
+            fieldBuilder.attribute(`default("${field.defaultValue}")`);
+          } else if (typeof field.defaultValue === "boolean" || typeof field.defaultValue === "number") {
+            fieldBuilder.attribute(`default(${field.defaultValue})`);
+          }
+        }
+        if (field.references) {
+          const refModelName = toPascalCase(field.references.model);
+          let action = "Cascade";
+          if (field.references.onDelete === "restrict")
+            action = "Restrict";
+          else if (field.references.onDelete === "set-null")
+            action = "SetNull";
+          const relationAttr = `relation(fields: [${fieldName}], references: [${field.references.field}], onDelete: ${action})`;
+          builder.model(modelName).field(field.references.model.toLowerCase(), `${refModelName}${field.required ? "" : "?"}`).attribute(relationAttr);
+        }
+        if (provider === "mysql" && field.type === "string" && !field.unique && !field.references) {
+          fieldBuilder.attribute("db.Text");
+        }
+      }
+      const hasMapAttr = builder.findByType("attribute", {
+        name: "map",
+        within: prismaModel?.properties
+      });
+      if (!hasMapAttr) {
+        builder.model(modelName).blockAttribute("map", table.prefixedName);
+      }
+    }
+  });
+  const schemaChanged = schema.trim() !== schemaPrisma.trim();
+  return {
+    code: schemaChanged ? schema : "",
+    fileName: filePath,
+    overwrite: schemaExists && schemaChanged
+  };
+};
+function getPrismaType(field, provider) {
+  const optional = !field.required && !field.primaryKey ? "?" : "";
+  switch (field.type) {
+    case "string":
+      return `String${optional}`;
+    case "number":
+      return `Int${optional}`;
+    case "boolean":
+      return `Boolean${optional}`;
+    case "date":
+      return `DateTime${optional}`;
+    case "json":
+      if (provider === "sqlite" || provider === "mysql") {
+        return `String${optional}`;
+      }
+      return `Json${optional}`;
+    default:
+      return `String${optional}`;
+  }
+}
+function toPascalCase(str) {
+  return str.split("_").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
+}
+function getNewPrisma(provider) {
+  return `generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "${provider}"
+  url      = ${provider === "sqlite" ? `"file:./dev.db"` : `env("DATABASE_URL")`}
+}`;
+}
+export {
+  generatePrismaSchema
+};

package/dist/chunk-nj3a3jzm.js

@@ -0,0 +1,26 @@
+// src/db/schema.ts
+function getServiceTables(services) {
+  const result = new Map;
+  for (const service of services) {
+    if (!service.dbSchema)
+      continue;
+    for (const [tableName, tableDef] of Object.entries(service.dbSchema.tables)) {
+      const prefixedName = `${service.id}_${tableName}`;
+      if (result.has(prefixedName)) {
+        throw new Error(`Table name collision: "${prefixedName}" is defined by multiple services`);
+      }
+      result.set(prefixedName, {
+        originalName: tableName,
+        prefixedName,
+        serviceId: service.id,
+        fields: tableDef.fields
+      });
+    }
+  }
+  return result;
+}
+function prefixTableName(serviceId, tableName) {
+  return `${serviceId}_${tableName}`;
+}
+
+export { getServiceTables, prefixTableName };

package/dist/chunk-q65vm76v.js

@@ -0,0 +1,180 @@
+import"./chunk-5va59f7m.js";
+
+// src/cli/generators/drizzle.ts
+var generateDrizzleSchema = async ({
+  tables,
+  provider,
+  file
+}) => {
+  const filePath = file || "./futonic-schema.ts";
+  let code = generateImport({ provider, tables });
+  for (const [, table] of tables) {
+    code += `
+${generateTable(table, provider)}
+`;
+  }
+  return {
+    code,
+    fileName: filePath
+  };
+};
+function generateTable(table, provider) {
+  const tableFunc = `${provider}Table`;
+  const fields = table.fields;
+  const indexes = [];
+  const columnDefs = Object.entries(fields).map(([fieldName, field]) => {
+    let col = getColumnType(fieldName, field, provider);
+    if (field.primaryKey) {
+      col += ".primaryKey()";
+    }
+    if (field.defaultValue !== null && field.defaultValue !== undefined) {
+      if (typeof field.defaultValue === "string") {
+        col += `.default("${field.defaultValue}")`;
+      } else {
+        col += `.default(${field.defaultValue})`;
+      }
+    }
+    if (field.required) {
+      col += ".notNull()";
+    }
+    if (field.unique) {
+      col += ".unique()";
+      indexes.push({
+        type: "uniqueIndex",
+        name: `${table.prefixedName}_${fieldName}_uidx`,
+        on: fieldName
+      });
+    }
+    if (field.references) {
+      const onDelete = field.references.onDelete || "cascade";
+      const action = onDelete === "set-null" ? "set null" : onDelete;
+      col += `.references(() => ${field.references.model}.${field.references.field}, { onDelete: '${action}' })`;
+    }
+    return `  ${fieldName}: ${col}`;
+  }).join(`,
+`);
+  const indexBlock = assignIndexes(indexes);
+  return `export const ${table.prefixedName} = ${tableFunc}("${table.prefixedName}", {
+${columnDefs}
+}${indexBlock});`;
+}
+function getColumnType(name, field, provider) {
+  if (field.enum && field.enum.length > 0) {
+    const enumValues = field.enum.map((v) => `'${v}'`).join(", ");
+    const typeMap2 = {
+      sqlite: `text("${name}")`,
+      pg: `text("${name}", { enum: [${enumValues}] })`,
+      mysql: `mysqlEnum("${name}", [${enumValues}])`
+    };
+    return typeMap2[provider];
+  }
+  const typeMap = {
+    string: {
+      sqlite: `text("${name}")`,
+      pg: `text("${name}")`,
+      mysql: field.unique ? `varchar("${name}", { length: 255 })` : field.references ? `varchar("${name}", { length: 36 })` : `text("${name}")`
+    },
+    boolean: {
+      sqlite: `integer("${name}", { mode: 'boolean' })`,
+      pg: `boolean("${name}")`,
+      mysql: `boolean("${name}")`
+    },
+    number: {
+      sqlite: `integer("${name}")`,
+      pg: `integer("${name}")`,
+      mysql: `int("${name}")`
+    },
+    date: {
+      sqlite: `integer("${name}", { mode: 'timestamp_ms' })`,
+      pg: `timestamp("${name}")`,
+      mysql: `timestamp("${name}", { fsp: 3 })`
+    },
+    json: {
+      sqlite: `text("${name}", { mode: "json" })`,
+      pg: `jsonb("${name}")`,
+      mysql: `json("${name}")`
+    }
+  };
+  const dbTypeMap = typeMap[field.type];
+  if (!dbTypeMap) {
+    throw new Error(`Unsupported field type '${field.type}' for field '${name}'.`);
+  }
+  return dbTypeMap[provider];
+}
+function assignIndexes(indexes) {
+  if (!indexes.length)
+    return "";
+  const lines = [", (table) => ["];
+  for (const index of indexes) {
+    lines.push(`  ${index.type}("${index.name}").on(table.${index.on}),`);
+  }
+  lines.push("]");
+  return lines.join(`
+`);
+}
+function generateImport({
+  provider,
+  tables
+}) {
+  const coreImports = [`${provider}Table`];
+  let hasJson = false;
+  let hasDate = false;
+  let hasBoolean = false;
+  let hasNumber = false;
+  let hasEnum = false;
+  for (const [, table] of tables) {
+    for (const field of Object.values(table.fields)) {
+      if (field.type === "json")
+        hasJson = true;
+      if (field.type === "date")
+        hasDate = true;
+      if (field.type === "boolean")
+        hasBoolean = true;
+      if (field.type === "number")
+        hasNumber = true;
+      if (field.enum && field.enum.length > 0)
+        hasEnum = true;
+    }
+  }
+  if (provider === "mysql") {
+    coreImports.push("varchar", "text");
+  } else {
+    coreImports.push("text");
+  }
+  if (hasNumber) {
+    if (provider === "mysql")
+      coreImports.push("int");
+    else
+      coreImports.push("integer");
+  }
+  if (hasBoolean && provider !== "sqlite") {
+    coreImports.push("boolean");
+  } else if (hasBoolean) {
+    if (!hasNumber)
+      coreImports.push("integer");
+  }
+  if (hasDate && provider !== "sqlite") {
+    coreImports.push("timestamp");
+  } else if (hasDate && !hasNumber && !hasBoolean) {
+    coreImports.push("integer");
+  }
+  if (hasJson) {
+    if (provider === "pg")
+      coreImports.push("jsonb");
+    if (provider === "mysql")
+      coreImports.push("json");
+  }
+  if (hasEnum && provider === "mysql") {
+    coreImports.push("mysqlEnum");
+  }
+  const hasUniqueIdx = [...tables.values()].some((t) => Object.values(t.fields).some((f) => f.unique));
+  if (hasUniqueIdx) {
+    coreImports.push("uniqueIndex");
+  }
+  const dedupedImports = [...new Set(coreImports)];
+  return `import { ${dedupedImports.join(", ")} } from "drizzle-orm/${provider}-core";
+`;
+}
+export {
+  generateDrizzleSchema
+};

package/dist/cli/generators/drizzle.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Drizzle ORM schema generator.
+ *
+ * Forked from better-auth `packages/cli/src/generators/drizzle.ts` (MIT).
+ * Adapted to read from futonic's PrefixedTable IR instead of getAuthTables().
+ * Generates pgTable/mysqlTable/sqliteTable definitions with column types,
+ * constraints, references, and indexes.
+ */
+import type { SchemaGenerator } from "./types";
+export declare const generateDrizzleSchema: SchemaGenerator;
+//# sourceMappingURL=drizzle.d.ts.map

package/dist/cli/generators/drizzle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drizzle.d.ts","sourceRoot":"","sources":["../../../src/cli/generators/drizzle.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAGX,eAAe,EACf,MAAM,SAAS,CAAC;AAEjB,eAAO,MAAM,qBAAqB,EAAE,eAiBnC,CAAC"}

package/dist/cli/generators/kysely.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Raw SQL DDL generator for Kysely / plain SQL migrations.
+ *
+ * better-auth's kysely generator delegates to `getMigrations()` which
+ * compiles DDL from their internal schema. We do the same thing here,
+ * generating CREATE TABLE statements from our PrefixedTable IR.
+ *
+ * Forked approach from better-auth `packages/cli/src/generators/kysely.ts` (MIT).
+ */
+import type { PrefixedTable } from "../../db/schema";
+import type { DatabaseProvider, SchemaGenerator } from "./types";
+export declare const generateKyselySchema: SchemaGenerator;
+/**
+ * Converts a PrefixedTable to a CREATE TABLE SQL statement.
+ */
+export declare function tableToSQL(table: PrefixedTable, provider?: DatabaseProvider): string;
+//# sourceMappingURL=kysely.d.ts.map

package/dist/cli/generators/kysely.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kysely.d.ts","sourceRoot":"","sources":["../../../src/cli/generators/kysely.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAmB,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACtE,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAEjE,eAAO,MAAM,oBAAoB,EAAE,eAmBlC,CAAC;AAEF;;GAEG;AACH,wBAAgB,UAAU,CACzB,KAAK,EAAE,aAAa,EACpB,QAAQ,GAAE,gBAAuB,GAC/B,MAAM,CAoBR"}

package/dist/cli/generators/prisma.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Prisma schema generator.
+ *
+ * Forked from better-auth `packages/cli/src/generators/prisma.ts` (MIT).
+ * Adapted to read from futonic's PrefixedTable IR instead of getAuthTables().
+ * Uses @mrleebo/prisma-ast for AST-based schema patching.
+ */
+import type { SchemaGenerator } from "./types";
+export declare const generatePrismaSchema: SchemaGenerator;
+//# sourceMappingURL=prisma.d.ts.map

package/dist/cli/generators/prisma.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prisma.d.ts","sourceRoot":"","sources":["../../../src/cli/generators/prisma.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAI/C,eAAO,MAAM,oBAAoB,EAAE,eAyHlC,CAAC"}

package/dist/cli/generators/types.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Generator types for CLI schema generation.
+ *
+ * Forked from better-auth `packages/cli/src/generators/types.ts` (MIT).
+ * Adapted to use futonic's ServiceDBSchema IR instead of BetterAuthOptions.
+ */
+import type { PrefixedTable } from "../../db/schema";
+export interface SchemaGeneratorResult {
+    code?: string;
+    fileName: string;
+    overwrite?: boolean;
+    append?: boolean;
+}
+export type DatabaseProvider = "pg" | "mysql" | "sqlite";
+export interface GeneratorOptions {
+    /** All prefixed tables collected from mounted services */
+    tables: Map<string, PrefixedTable>;
+    /** Target database provider */
+    provider: DatabaseProvider;
+    /** Output file path override */
+    file?: string;
+}
+export type SchemaGenerator = (opts: GeneratorOptions) => Promise<SchemaGeneratorResult>;
+//# sourceMappingURL=types.d.ts.map

package/dist/cli/generators/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/cli/generators/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAErD,MAAM,WAAW,qBAAqB;IACrC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,MAAM,gBAAgB,GAAG,IAAI,GAAG,OAAO,GAAG,QAAQ,CAAC;AAEzD,MAAM,WAAW,gBAAgB;IAChC,0DAA0D;IAC1D,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IACnC,+BAA+B;IAC/B,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,gCAAgC;IAChC,IAAI,CAAC,EAAE,MAAM,CAAC;CACd;AAED,MAAM,MAAM,eAAe,GAAG,CAC7B,IAAI,EAAE,gBAAgB,KAClB,OAAO,CAAC,qBAAqB,CAAC,CAAC"}

package/dist/cli/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * CLI factory for service authors.
+ *
+ * Service packages wrap this to provide their own CLI:
+ *
+ * ```ts
+ * // packages/acme-billing/src/cli.ts
+ * #!/usr/bin/env node
+ * import { createCLI } from "futonic/cli";
+ * import { billingService } from "./service";
+ *
+ * createCLI({ service: billingService });
+ * ```
+ *
+ * The host developer then runs:
+ *   npx acme-billing generate --orm=drizzle --provider=pg
+ *
+ * And gets migration files for just that service's tables.
+ */
+import type { EmbeddableService } from "../core/service";
+export interface CLIOptions {
+    /** The service definition (pre-mount, has dbSchema) */
+    service: EmbeddableService;
+    /** Optional name override for CLI output (defaults to service.id) */
+    name?: string;
+}
+export declare function createCLI(options: CLIOptions): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAIzD,MAAM,WAAW,UAAU;IAC1B,uDAAuD;IACvD,OAAO,EAAE,iBAAiB,CAAC;IAC3B,qEAAqE;IACrE,IAAI,CAAC,EAAE,MAAM,CAAC;CACd;AAED,wBAAgB,SAAS,CAAC,OAAO,EAAE,UAAU,GAAG,IAAI,CAgBnD"}

package/dist/cli/index.js

@@ -0,0 +1,101 @@
+import {
+  getServiceTables
+} from "../chunk-nj3a3jzm.js";
+import {
+  __require,
+  __toESM
+} from "../chunk-5va59f7m.js";
+
+// src/cli/index.ts
+import { writeFile, mkdir } from "node:fs/promises";
+import path from "node:path";
+function createCLI(options) {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  const serviceName = options.name ?? options.service.id;
+  switch (command) {
+    case "generate":
+      runGenerate(args.slice(1), options).catch((err) => {
+        console.error(err);
+        process.exit(1);
+      });
+      break;
+    default:
+      printUsage(serviceName);
+      process.exit(command ? 1 : 0);
+  }
+}
+function printUsage(name) {
+  console.log(`
+${name} CLI (powered by futonic)
+
+Usage:
+  ${name} generate --orm=<drizzle|prisma|kysely> [options]
+
+Commands:
+  generate    Generate database schema files for the host application
+
+Options:
+  --orm        Target ORM (required): drizzle, prisma, kysely
+  --provider   Database provider: pg, mysql, sqlite (default: pg)
+  --out        Output file path (optional, defaults vary by ORM)
+`);
+}
+function parseFlag(flags, name) {
+  const flag = flags.find((a) => a.startsWith(`--${name}=`));
+  return flag?.split("=")[1];
+}
+async function runGenerate(flags, options) {
+  const { service } = options;
+  const serviceName = options.name ?? service.id;
+  const orm = parseFlag(flags, "orm");
+  if (!orm) {
+    console.error("Error: --orm flag is required");
+    console.error(`  ${serviceName} generate --orm=drizzle|prisma|kysely`);
+    process.exit(1);
+  }
+  const provider = parseFlag(flags, "provider") ?? "pg";
+  if (!["pg", "mysql", "sqlite"].includes(provider)) {
+    console.error(`Invalid provider: ${provider}. Must be pg, mysql, or sqlite`);
+    process.exit(1);
+  }
+  const outPath = parseFlag(flags, "out");
+  const tables = getServiceTables([
+    {
+      ...service,
+      mountConfig: { mount: "" }
+    }
+  ]);
+  const generator = await loadGenerator(orm);
+  const result = await generator({ tables, provider, file: outPath });
+  if (!result.code) {
+    console.log(`[${serviceName}] No schema changes detected.`);
+    return;
+  }
+  const dir = path.dirname(result.fileName);
+  await mkdir(dir, { recursive: true });
+  await writeFile(result.fileName, result.code, "utf-8");
+  console.log(`[${serviceName}] Generated ${orm} schema → ${result.fileName}`);
+}
+async function loadGenerator(orm) {
+  switch (orm) {
+    case "drizzle": {
+      const { generateDrizzleSchema } = await import("../chunk-q65vm76v.js");
+      return generateDrizzleSchema;
+    }
+    case "prisma": {
+      const { generatePrismaSchema } = await import("../chunk-j2yky04y.js");
+      return generatePrismaSchema;
+    }
+    case "kysely": {
+      const { generateKyselySchema } = await import("../chunk-6w1vqkpr.js");
+      return generateKyselySchema;
+    }
+    default:
+      console.error(`Unknown ORM: ${orm}. Supported: drizzle, prisma, kysely`);
+      process.exit(1);
+  }
+}
+export {
+  createCLI
+};

package/dist/client/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Re-exports better-call's client utilities for type-safe API consumption.
+ *
+ * Usage:
+ * ```ts
+ * import { createClient } from "futonic/client";
+ * import type { billingRouter } from "@acme/billing";
+ *
+ * const client = createClient<typeof billingRouter>({
+ *   baseURL: "/api/billing",
+ * });
+ * ```
+ */
+export { createClient } from "better-call/client";
+//# sourceMappingURL=index.d.ts.map

package/dist/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/client/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC"}