turbine-orm 0.4.0 → 0.7.0

package/dist/cjs/serverless.js

@@ -0,0 +1,110 @@
+"use strict";
+/**
+ * turbine-orm/serverless — edge / serverless driver integration
+ *
+ * Turbine runs on any Postgres driver that speaks the node-postgres API.
+ * This module exposes a thin factory (`turbineHttp`) that binds an external
+ * pg-compatible pool to a schema, so you can use Turbine on Vercel Edge,
+ * Cloudflare Workers, Deno Deploy, Netlify Edge, or any other environment
+ * where a direct TCP connection is unavailable.
+ *
+ * ## Supported drivers
+ *
+ * Any driver whose `Pool` satisfies `PgCompatPool` will work. The ones
+ * below are verified:
+ *
+ * - **Neon** (`@neondatabase/serverless`) — HTTP and WebSocket transports
+ * - **Vercel Postgres** (`@vercel/postgres`) — wraps Neon
+ * - **Cloudflare Hyperdrive** — exposes a pg-compatible driver
+ * - **Supabase** — use the regular `pg` package; Supabase is Postgres-native
+ *
+ * Turbine does NOT bundle any of these — install whichever you need and
+ * pass its pool directly.
+ *
+ * ## Limitations over HTTP
+ *
+ * - **Streaming cursors** (`findManyStream`, `findManyCursor`) require
+ *   server-side `DECLARE CURSOR`, which most HTTP drivers do not support.
+ *   If you call these on an HTTP pool the underlying driver will error.
+ * - **LISTEN/NOTIFY** is not available over HTTP.
+ * - **Transactions** are supported but each transaction holds an HTTP
+ *   connection for its duration — keep them short.
+ *
+ * ## Example — Neon on Vercel Edge
+ *
+ * ```ts
+ * // app/api/users/route.ts
+ * import { Pool } from '@neondatabase/serverless';
+ * import { turbineHttp } from 'turbine-orm/serverless';
+ * import { schema } from '@/generated/turbine/metadata';
+ *
+ * export const runtime = 'edge';
+ *
+ * const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+ * const db = turbineHttp(pool, schema);
+ *
+ * export async function GET() {
+ *   const users = await db.table('users').findMany({ limit: 10 });
+ *   return Response.json(users);
+ * }
+ * ```
+ *
+ * ## Example — Supabase (direct Postgres, no HTTP proxy needed)
+ *
+ * ```ts
+ * import { TurbineClient } from 'turbine-orm';
+ * import { schema } from './generated/turbine/metadata.js';
+ *
+ * const db = new TurbineClient({
+ *   connectionString: process.env.SUPABASE_DB_URL,
+ *   ssl: { rejectUnauthorized: false },
+ * }, schema);
+ * ```
+ *
+ * ## Example — Cloudflare Workers
+ *
+ * ```ts
+ * // Use the Neon HTTP driver which works in Workers runtime
+ * import { Pool } from '@neondatabase/serverless';
+ * import { turbineHttp } from 'turbine-orm/serverless';
+ *
+ * export default {
+ *   async fetch(req: Request, env: Env) {
+ *     const pool = new Pool({ connectionString: env.DATABASE_URL });
+ *     const db = turbineHttp(pool, schema);
+ *     const users = await db.table('users').findMany({ limit: 10 });
+ *     return Response.json(users);
+ *   }
+ * };
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.turbineHttp = turbineHttp;
+const client_js_1 = require("./client.js");
+/**
+ * Create a TurbineClient bound to an external pg-compatible pool.
+ *
+ * Use this for serverless/edge environments where Turbine should NOT
+ * manage its own `pg.Pool`. The caller retains ownership of the pool's
+ * lifecycle — `db.disconnect()` is a no-op.
+ *
+ * @param pool - Any pg-compatible pool (Neon, Vercel Postgres, etc.)
+ * @param schema - Introspected or hand-written schema metadata
+ * @param options - Optional logging / defaultLimit / warnOnUnlimited
+ * @returns A TurbineClient instance
+ *
+ * @example
+ * ```ts
+ * import { Pool } from '@neondatabase/serverless';
+ * import { turbineHttp } from 'turbine-orm/serverless';
+ * import { schema } from './generated/turbine/metadata.js';
+ *
+ * const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+ * const db = turbineHttp(pool, schema);
+ *
+ * const users = await db.table('users').findMany({ limit: 10 });
+ * ```
+ */
+function turbineHttp(pool, schema, options = {}) {
+    return new client_js_1.TurbineClient({ pool, ...options }, schema);
+}

package/dist/cli/config.js

@@ -5,17 +5,12 @@
  * Falls back to CLI args and environment variables.
  */
 import { existsSync } from 'node:fs';
-import { resolve, join } from 'node:path';
+import { join, resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
 // ---------------------------------------------------------------------------
 // Config file names, in priority order
 // ---------------------------------------------------------------------------
-const CONFIG_FILES = [
-    'turbine.config.ts',
-    'turbine.config.mts',
-    'turbine.config.js',
-    'turbine.config.mjs',
-];
+const CONFIG_FILES = ['turbine.config.ts', 'turbine.config.mts', 'turbine.config.js', 'turbine.config.mjs'];
 // ---------------------------------------------------------------------------
 // Load config
 // ---------------------------------------------------------------------------
@@ -67,10 +62,7 @@ export function findConfigFile(cwd) {
  */
 export function resolveConfig(fileConfig, overrides) {
     return {
-        url: overrides.url ??
-            process.env['DATABASE_URL'] ??
-            fileConfig.url ??
-            '',
+        url: overrides.url ?? process.env.DATABASE_URL ?? fileConfig.url ?? '',
         out: overrides.out ?? fileConfig.out ?? './generated/turbine',
         schema: overrides.schema ?? fileConfig.schema ?? 'public',
         include: overrides.include ?? fileConfig.include ?? [],
@@ -84,15 +76,13 @@ export function resolveConfig(fileConfig, overrides) {
 // Config file template (for `turbine init`)
 // ---------------------------------------------------------------------------
 export function configTemplate(connectionString) {
-    const url = connectionString ?? 'process.env.DATABASE_URL';
-    const urlLine = connectionString
-        ? `  url: '${connectionString}',`
-        : `  url: process.env.DATABASE_URL,`;
+    const _url = connectionString ?? 'process.env.DATABASE_URL';
+    const urlLine = connectionString ? `  url: '${connectionString}',` : `  url: process.env.DATABASE_URL,`;
     return `import type { TurbineCliConfig } from 'turbine-orm/cli';
 
 /**
  * Turbine configuration
- * @see https://github.com/zvndev/turbine-orm
+ * @see https://turbineorm.dev
  */
 const config: TurbineCliConfig = {
   /** Postgres connection string */