futonic 0.0.0-canary.03da5f8

package/README.md

@@ -0,0 +1,219 @@
+# Futonic 🛋️
+
+**A framework for building services that embed into host applications instead of deploying alongside them.**
+
+## The problem
+
+There are plenty of services available as easy-to-deploy containers — auth servers, payment processors, observability tools. But for most applications, deploying multiple containers (one for the main app plus one for each service) is a waste. An auth server, a payment webhook handler, and an observability stack don't each need their own process. They could share compute and a database without any meaningful noisy-neighbor issues — because let's be honest, most apps these days are just wrappers around heavier services anyway.
+
+## The idea
+
+Futonic is heavily inspired by [better-auth](https://github.com/better-auth/better-auth)'s service embedding paradigm — the insight that many services don't need their own process, their own deployment, or even their own database. They just need a place to crash.
+
+Futonic is a framework for building **embeddable services** that crash on a host application's futon. They share the host's compute. They share the host's database. They wake up when needed and stay out of the way when they're not.
+
+No separate containers. No extra Dockerfiles. No internal networking. Just services that live inside the host app — and a great DX for building them.
+
+## Why build embeddable services
+
+**Your users save money:**
+Most apps aren't mega-scale. They're tools, SaaS products, and indie projects where every dollar of infrastructure counts. When your service embeds directly into the host, your users don't need to pay for another container sitting idle 99% of the time.
+
+**Your users get a better dev experience:**
+No more `docker-compose up` with 6 services just to work on a feature. No more debugging why the auth container can't talk to the payments container on a laptop. Embedded services run in-process. Switch branches, switch worktrees — everything just works.
+
+**Simplicity sells:**
+Fewer moving parts means fewer things that break at 2am. One deploy. One database. One set of logs. Developers can always decompose later if they outgrow it — but most apps never will. The easier your service is to adopt, the more people will use it.
+
+## How it works: the vertical slice
+
+A futonic service is a **vertical slice** of your application. It defines everything from the client interface down to the database — API endpoints, input validation, business logic, and table schemas — as a single, self-contained unit.
+
+```mermaid
+block-beta
+  columns 3
+  block:host["Host Application"]:3
+    columns 3
+    space:3
+    block:app["Your App Code"]:1
+      columns 1
+      appRoutes["Routes"]
+      appLogic["Logic"]
+      appTables["Tables"]
+    end
+    block:billing["@acme/billing"]:1
+      columns 1
+      billingAPI["Endpoints"]
+      billingLogic["Logic"]
+      billingTables["Tables"]
+    end
+    block:auth["@acme/auth"]:1
+      columns 1
+      authAPI["Endpoints"]
+      authLogic["Logic"]
+      authTables["Tables"]
+    end
+    space:3
+  end
+
+  style billing stroke:#22c55e,stroke-width:2px
+  style auth stroke:#22c55e,stroke-width:2px
+  style app stroke:#6366f1,stroke-width:2px
+```
+
+Each green block is a futonic service — a vertical slice that owns its entire stack, published as an npm package. The host application mounts them alongside its own code. They all share one process, one database, one deployment.
+
+This is what makes futonic different from microservices. A microservice is also a vertical slice, but it pays for that independence with its own container, its own deployment pipeline, and network hops between every call. A futonic service gets the same self-containment for free:
+
+- **No deployment cost.** It runs inside your existing process. No extra containers, no extra infrastructure, no extra cloud bill.
+- **No networking latency.** Service calls from backend code are direct function calls — same process, same database connection pool, zero serialization.
+- **No protocol constraints.** Endpoints are built on web standard `Request`/`Response`, so a service can return JSON, full HTML pages, server-sent event streams, file downloads — anything `Response` supports.
+
+### What a service looks like
+
+A service defines its database tables and API endpoints. The service author publishes this as an npm package:
+
+```typescript
+// @acme/billing
+
+import { createService, createEndpoint } from "futonic";
+
+export const billing = createService({
+  id: "billing",
+  version: "0.1.0",
+  dependencies: { database: true },
+  dbSchema: {
+    tables: {
+      invoices: {
+        fields: {
+          id: { type: "string", primaryKey: true, required: true },
+          amount: { type: "number", required: true },
+          status: { type: "string", required: true },
+        },
+      },
+    },
+  },
+});
+```
+
+Endpoints receive a `ServiceContext` via middleware — giving them scoped access to the service's database tables, config, and logger:
+
+```typescript
+export function createBillingEndpoints(use: Middleware[]) {
+  return {
+    createInvoice: createEndpoint(
+      "/invoices",
+      { method: "POST", use, body: z.object({ amount: z.number(), status: z.string() }) },
+      async (ctx) => {
+        const svc = ctx.context.serviceCtx;
+        const invoice = await svc.db.invoices.create({
+          id: crypto.randomUUID(),
+          ...ctx.body,
+        });
+        svc.logger.info(`Invoice created: ${invoice.id}`);
+        return invoice;
+      },
+    ),
+  };
+}
+```
+
+The endpoint writes to `svc.db.invoices`, but the actual table in the database is `billing_invoices` — automatically prefixed with the service ID. A second service with its own `invoices` table would hit a completely separate table. Same database, no collisions.
+
+### How the host mounts it
+
+The host developer installs the service and wires it in. Futonic auto-detects the database driver — `pg`, `mysql2`, `better-sqlite3`, or `bun:sqlite`:
+
+```typescript
+import { createHost } from "futonic";
+import { billing, createBillingRouter } from "@acme/billing";
+
+const host = createHost({
+  database: pool,  // Their existing pg.Pool, mysql2 pool, or sqlite instance
+  baseURL: "http://localhost:3000",
+  services: [
+    billing({ mount: "/api/billing" }),
+  ],
+});
+
+await host.init();
+```
+
+Then a single catch-all route in their framework of choice:
+
+```typescript
+// Hono
+app.all("/api/billing/*", (c) => billingRouter.handler(c.req.raw));
+
+// Next.js — app/api/billing/[...path]/route.ts
+import { toNextJsHandler } from "futonic/next";
+export const { GET, POST, PUT, DELETE, PATCH } = toNextJsHandler(billingRouter);
+```
+
+That's it. The billing service handles requests at `/api/billing/*`, stores data in the host's database under prefixed tables, and the host didn't need to understand any of the service's internals to set it up.
+
+## More features
+
+### Type-safe RPC from the frontend
+
+Host developers consume your service from their frontend with a fully typed client — autocomplete, return types, and error types included:
+
+```typescript
+import { createClient } from "futonic/client";
+import type { BillingRouter } from "@acme/billing";
+
+const billing = createClient<BillingRouter>({
+  baseURL: "/api/billing",
+});
+
+const { data } = await billing.listInvoices();
+const { data: invoice } = await billing.createInvoice({
+  body: { amount: 4200, status: "draft" },
+});
+```
+
+### Skip networking on the backend
+
+When the host's backend code needs to call the service, there's no HTTP round-trip. The service runs in the same process, shares the same database connection pool, and returns results directly:
+
+```typescript
+const svc = host.services.get("billing").serviceContext!;
+const invoices = await svc.db.invoices.findMany();
+```
+
+### Generate migrations for any ORM
+
+Ship a CLI so your users can generate migration files for their ORM of choice:
+
+```bash
+npx @acme/billing generate --orm=drizzle --provider=pg --out=schema.ts
+npx @acme/billing generate --orm=prisma --provider=mysql
+npx @acme/billing generate --orm=kysely --provider=sqlite
+```
+
+### Return any web standard response
+
+Endpoints aren't limited to JSON. Serve full HTML pages for embedded UIs, server-sent event streams for real-time updates, file downloads, redirects — whatever `Response` supports. Build an entire admin dashboard that lives inside the host app.
+
+## Things you could build
+
+- **Auth service** — User management, sessions, OAuth flows, and permissions. Like better-auth, but packaged as an embeddable service.
+- **Payment service** — Webhook handlers, invoice management, subscription state. A reusable Stripe integration that anyone can drop into their app.
+- **Observability service** — An API for ingesting traces, database tables for storing them, and an embedded UI for visualizing them. Jaeger without the deployment.
+- **Feature flags** — A flag service with an admin UI, backed by the host's existing database.
+- **CMS** — Content management endpoints with an embedded editor interface.
+- **Notifications** — Email/push queue management with status tracking and retry logic.
+
+## Database support
+
+Futonic auto-detects your database driver and works with:
+
+- **PostgreSQL** via `pg`
+- **MySQL** via `mysql2`
+- **SQLite** via `better-sqlite3` or Bun's built-in `bun:sqlite`
+
+Your service works with whatever database the host is already running — no extra configuration on your end.
+
+## License
+
+MIT

package/dist/chunk-eqeddyek.js

@@ -0,0 +1,130 @@
+import {
+  __require
+} from "./chunk-v0bahtg2.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 referencedTable = `${table.serviceId}_${field.references.model}`;
+          const refModelName = toPascalCase(referencedTable);
+          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(referencedTable.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-s3j6ndfy.js

@@ -0,0 +1,96 @@
+import"./chunk-v0bahtg2.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();
+      const referencedTable = `${table.serviceId}_${field.references.model}`;
+      columns.push(`  FOREIGN KEY (${fieldName}) REFERENCES ${referencedTable}(${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;
+    case "binary":
+      if (provider === "pg")
+        type = "BYTEA";
+      else if (provider === "mysql")
+        type = "LONGBLOB";
+      else
+        type = "BLOB";
+      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-s9sdjw1m.js

@@ -0,0 +1,181 @@
+import"./chunk-v0bahtg2.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;
+      const referencedTable = `${table.serviceId}_${field.references.model}`;
+      col += `.references(() => ${referencedTable}.${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/chunk-v0bahtg2.js

@@ -0,0 +1,4 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+export { __require };

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