turbine-orm 0.5.0 → 0.7.1

package/dist/cjs/schema.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * @batadata/turbine — Schema metadata types
+ * turbine-orm — Schema metadata types
  *
  * These types represent the introspected database schema at runtime.
  * They're used by the query builder, code generator, and CLI.
@@ -20,6 +20,9 @@ const PG_TO_TS = {
     // Integers
     int2: 'number',
     int4: 'number',
+    // int8 maps to `number` for DX (auto-increment IDs, counts, etc.).
+    // Values exceeding Number.MAX_SAFE_INTEGER (2^53 - 1) are returned as
+    // `string` at runtime to avoid precision loss. See client.ts int8 parser.
     int8: 'number',
     float4: 'number',
     float8: 'number',
@@ -128,7 +131,7 @@ function snakeToPascal(s) {
 /** Naive singularize: "posts" → "post", "categories" → "category" */
 function singularize(s) {
     if (s.endsWith('ies'))
-        return s.slice(0, -3) + 'y';
+        return `${s.slice(0, -3)}y`;
     if (s.endsWith('ses') || s.endsWith('xes') || s.endsWith('zes'))
         return s.slice(0, -2);
     if (s.endsWith('s') && !s.endsWith('ss'))

package/dist/cjs/serverless.js

@@ -1,199 +1,111 @@
 "use strict";
 /**
- * @batadata/turbine/serverless — HTTP-based query driver for edge functions
+ * turbine-orm/serverless — edge / serverless driver integration
  *
- * Use this driver when you cannot establish a direct TCP connection to Postgres
- * (e.g., Vercel Edge Functions, Cloudflare Workers, Deno Deploy).
+ * 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.
  *
- * It sends queries as JSON over HTTP to a Turbine query endpoint, which executes
- * them against the actual database and returns typed results.
+ * ## Supported drivers
  *
- * NOTE: This is a scaffold. The server-side query endpoint does not exist yet.
- * The HTTP protocol and response format are defined here and will be implemented
- * on the server side in a future release.
+ * 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)
  *
- * @example
  * ```ts
- * import { createServerlessClient } from '@batadata/turbine/serverless';
+ * 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);
+ * ```
  *
- * const db = createServerlessClient({
- *   endpoint: 'https://your-turbine-proxy.fly.dev/query',
- *   authToken: process.env.TURBINE_AUTH_TOKEN!,
- * });
+ * ## Example — Cloudflare Workers
  *
- * const result = await db.query('SELECT * FROM users WHERE id = $1', [1]);
+ * ```ts
+ * // Use the Neon HTTP driver which works in Workers runtime
+ * import { Pool } from '@neondatabase/serverless';
+ * import { turbineHttp } from 'turbine-orm/serverless';
+ * import { SCHEMA } from './generated/turbine/metadata';
+ *
+ * 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.ServerlessClient = void 0;
-exports.createServerlessClient = createServerlessClient;
-// ---------------------------------------------------------------------------
-// Serverless client
-// ---------------------------------------------------------------------------
+exports.turbineHttp = turbineHttp;
+const client_js_1 = require("./client.js");
 /**
- * HTTP-based Postgres query client for serverless/edge environments.
+ * Create a TurbineClient bound to an external pg-compatible pool.
  *
- * Sends SQL queries as JSON POST requests to a Turbine query endpoint.
- * Does not require a direct TCP connection to Postgres.
- */
-class ServerlessClient {
-    config;
-    fetchFn;
-    constructor(config) {
-        if (!config.endpoint) {
-            throw new Error('[turbine/serverless] endpoint is required');
-        }
-        if (!config.authToken) {
-            throw new Error('[turbine/serverless] authToken is required');
-        }
-        this.config = {
-            ...config,
-            timeout: config.timeout ?? 10_000,
-        };
-        this.fetchFn = config.fetch ?? globalThis.fetch;
-    }
-    /**
-     * Execute a single SQL query.
-     *
-     * @param sql - SQL string with $1, $2, ... placeholders
-     * @param params - Parameter values
-     * @returns Query result with typed rows
-     *
-     * @example
-     * ```ts
-     * const result = await client.query<{ id: number; name: string }>(
-     *   'SELECT id, name FROM users WHERE org_id = $1',
-     *   [42]
-     * );
-     * console.log(result.rows);
-     * ```
-     */
-    async query(sql, params) {
-        const request = { sql, params, mode: 'rows' };
-        const response = await this.post('/query', request);
-        return response;
-    }
-    /**
-     * Execute a single SQL query and return the first row, or null.
-     */
-    async queryOne(sql, params) {
-        const request = { sql, params, mode: 'one' };
-        const response = await this.post('/query', request);
-        return response.rows[0] ?? null;
-    }
-    /**
-     * Execute a batch of queries in a single HTTP request.
-     * Optionally wraps them in a transaction.
-     *
-     * @param queries - Array of queries to execute
-     * @param options - Batch options
-     * @returns Array of results, one per query
-     *
-     * @example
-     * ```ts
-     * const results = await client.batch([
-     *   { sql: 'SELECT * FROM users WHERE id = $1', params: [1] },
-     *   { sql: 'SELECT COUNT(*) FROM posts WHERE user_id = $1', params: [1] },
-     * ], { transaction: true });
-     * ```
-     */
-    async batch(queries, options) {
-        const request = {
-            queries,
-            transaction: options?.transaction ?? false,
-        };
-        return this.post('/batch', request);
-    }
-    /**
-     * Tagged template helper for SQL queries.
-     *
-     * @example
-     * ```ts
-     * const users = await client.sql<{ id: number; name: string }>`
-     *   SELECT id, name FROM users WHERE org_id = ${orgId}
-     * `;
-     * ```
-     */
-    async sql(strings, ...values) {
-        let sqlStr = '';
-        strings.forEach((str, i) => {
-            sqlStr += str;
-            if (i < values.length) {
-                sqlStr += `$${i + 1}`;
-            }
-        });
-        const result = await this.query(sqlStr, values);
-        return result.rows;
-    }
-    // -------------------------------------------------------------------------
-    // Internal HTTP transport
-    // -------------------------------------------------------------------------
-    async post(path, body) {
-        const url = this.config.endpoint.replace(/\/$/, '') + path;
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
-        try {
-            const response = await this.fetchFn(url, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'Authorization': `Bearer ${this.config.authToken}`,
-                    'User-Agent': '@batadata/turbine-serverless',
-                    ...this.config.headers,
-                },
-                body: JSON.stringify(body),
-                signal: controller.signal,
-            });
-            if (!response.ok) {
-                const errorBody = await response.text();
-                let parsed;
-                try {
-                    parsed = JSON.parse(errorBody);
-                }
-                catch {
-                    // Not JSON
-                }
-                const message = parsed?.error ?? `HTTP ${response.status}: ${errorBody.slice(0, 200)}`;
-                const err = new Error(`[turbine/serverless] ${message}`);
-                err['status'] = response.status;
-                err['code'] = parsed?.code;
-                throw err;
-            }
-            return (await response.json());
-        }
-        catch (err) {
-            if (err instanceof DOMException && err.name === 'AbortError') {
-                throw new Error(`[turbine/serverless] Request timed out after ${this.config.timeout}ms`);
-            }
-            throw err;
-        }
-        finally {
-            clearTimeout(timeoutId);
-        }
-    }
-}
-exports.ServerlessClient = ServerlessClient;
-// ---------------------------------------------------------------------------
-// Factory function
-// ---------------------------------------------------------------------------
-/**
- * Create a serverless Turbine client for edge/serverless environments.
+ * 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 config - Endpoint URL and auth token
- * @returns A ServerlessClient instance
+ * @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 { createServerlessClient } from '@batadata/turbine/serverless';
+ * import { Pool } from '@neondatabase/serverless';
+ * import { turbineHttp } from 'turbine-orm/serverless';
+ * import { SCHEMA } from './generated/turbine/metadata.js';
  *
- * const db = createServerlessClient({
- *   endpoint: process.env.TURBINE_ENDPOINT!,
- *   authToken: process.env.TURBINE_AUTH_TOKEN!,
- * });
+ * const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+ * const db = turbineHttp(pool, SCHEMA);
  *
- * const users = await db.sql`SELECT * FROM users LIMIT 10`;
+ * const users = await db.table('users').findMany({ limit: 10 });
  * ```
  */
-function createServerlessClient(config) {
-    return new ServerlessClient(config);
+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://batadata.com/docs/turbine/config
+ * @see https://turbineorm.dev
  */
 const config: TurbineCliConfig = {
   /** Postgres connection string */