@pineliner/odb-client 1.0.0

package/src/core/transaction.ts

@@ -0,0 +1,425 @@
+import type { Transaction, QueryResult, TransactionCallback, SQLFragment } from '../types.ts';
+import type { HTTPClient } from './http-client.ts';
+import { SQLParser } from './sql-parser.ts';
+import { QueryError } from '../types.ts';
+
+/**
+ * Create a transaction function similar to the main sql function
+ */
+export function createTransaction(httpClient: HTTPClient): Transaction {
+  let isCommitted = false;
+  let isRolledBack = false;
+  const queries: Array<{ sql: string; params: any[] }> = [];
+
+  const checkTransactionState = (): void => {
+    if (isCommitted) {
+      throw new QueryError('Transaction has already been committed');
+    }
+    if (isRolledBack) {
+      throw new QueryError('Transaction has been rolled back');
+    }
+  };
+
+  const isReadQuery = (sql: string): boolean => {
+    const trimmed = sql.trim().toUpperCase();
+    return trimmed.startsWith('SELECT') ||
+           trimmed.startsWith('WITH') ||
+           trimmed.startsWith('EXPLAIN') ||
+           trimmed.startsWith('PRAGMA');
+  };
+
+  // Create the callable transaction function with context awareness
+  const txFunction = <T = any>(sql: TemplateStringsArray | any, ...values: any[]): Promise<QueryResult<T>> | SQLFragment => {
+    checkTransactionState();
+
+    // Handle template string queries (returns Promise)
+    if (Array.isArray(sql) && (('raw' in sql) || (typeof sql[0] === 'string' && values.length >= 0))) {
+      const parsed = SQLParser.parse(sql, values);
+
+      // For read queries, execute immediately
+      if (isReadQuery(parsed.sql)) {
+        return httpClient.query<T>(parsed.sql, parsed.params);
+      }
+
+      // For write queries, queue them for batch execution
+      queries.push(parsed);
+
+      // Return a placeholder result for queued queries
+      return Promise.resolve({
+        rows: [],
+        rowsAffected: 0,
+        executionTime: 0
+      });
+    }
+
+    // Handle direct object/array inputs (returns SQLFragment for composing)
+    const parsed = SQLParser.parse(sql, values);
+    return {
+      text: parsed.sql,
+      values: parsed.params
+    };
+  };
+
+  // Attach utility methods to the transaction function
+  txFunction.raw = (text: string): string => SQLParser.raw(text);
+  txFunction.identifier = (name: string): string => SQLParser.identifier(name);
+
+  txFunction.commit = async (): Promise<void> => {
+    checkTransactionState();
+
+    try {
+      // Execute BEGIN
+      await httpClient.query('BEGIN');
+
+      // Execute all queued queries
+      for (const query of queries) {
+        await httpClient.query(query.sql, query.params);
+      }
+
+      // Commit the transaction
+      await httpClient.query('COMMIT');
+
+      isCommitted = true;
+    } catch (error) {
+      // Rollback on any error
+      try {
+        await httpClient.query('ROLLBACK');
+      } catch (rollbackError) {
+        // Ignore rollback errors
+      }
+
+      isRolledBack = true;
+      throw new QueryError(
+        `Transaction failed: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        undefined,
+        undefined,
+        error instanceof Error ? error : undefined
+      );
+    }
+  };
+
+  txFunction.rollback = async (): Promise<void> => {
+    checkTransactionState();
+
+    try {
+      // If we have any queries, we need to actually rollback
+      if (queries.length > 0) {
+        await httpClient.query('ROLLBACK');
+      }
+    } finally {
+      isRolledBack = true;
+    }
+  };
+
+  txFunction.savepoint = async <T = any>(callback: (sql: Transaction) => Promise<T>): Promise<T> => {
+    checkTransactionState();
+
+    // For batched transactions, create a sub-transaction that shares the same logic
+    // but manages its own query queue for savepoint isolation
+    let savepointCommitted = false;
+    const savepointQueries: Array<{ sql: string; params: any[] }> = [];
+
+    // Create a savepoint transaction that collects queries locally
+    const savepointTx = <U = any>(sql: TemplateStringsArray | any, ...values: any[]): Promise<QueryResult<U>> | SQLFragment => {
+      if (isCommitted || isRolledBack) {
+        throw new QueryError('Transaction is no longer active');
+      }
+
+      // Handle template string queries (returns Promise)
+      if (Array.isArray(sql) && 'raw' in sql && typeof sql[0] === 'string') {
+        const parsed = SQLParser.parse(sql, values);
+
+        // For read queries, execute immediately
+        if (isReadQuery(parsed.sql)) {
+          return httpClient.query<U>(parsed.sql, parsed.params);
+        }
+
+        // For write queries, queue them in the savepoint queue
+        savepointQueries.push(parsed);
+
+        // Return a placeholder result for queued queries
+        return Promise.resolve({
+          rows: [],
+          rowsAffected: 0,
+          executionTime: 0
+        });
+      }
+
+      // Handle direct object/array inputs (returns SQLFragment for composing)
+      const parsed = SQLParser.parse(sql, values);
+      return {
+        text: parsed.sql,
+        values: parsed.params
+      };
+    };
+
+    // Attach utility methods to the savepoint transaction
+    (savepointTx as any).raw = (text: string): string => SQLParser.raw(text);
+    (savepointTx as any).identifier = (name: string): string => SQLParser.identifier(name);
+    (savepointTx as any).commit = async (): Promise<void> => {
+      savepointCommitted = true;
+    };
+    (savepointTx as any).rollback = async (): Promise<void> => {
+      // Rollback just clears the savepoint queries
+      savepointQueries.length = 0;
+    };
+
+    try {
+      // Execute the callback with the savepoint transaction
+      const result = await callback(savepointTx as Transaction);
+
+      // If successful, commit the savepoint by adding queries to main transaction
+      if (savepointCommitted || savepointQueries.length > 0) {
+        queries.push(...savepointQueries);
+      }
+
+      return result;
+    } catch (error) {
+      // On error, we don't add the savepoint queries to our queue
+      // This simulates a rollback to savepoint
+      throw error;
+    }
+  };
+
+  return txFunction as Transaction;
+}
+
+/**
+ * Transaction implementation for ODBLite
+ * Note: SQLite transactions are simulated at the client level since ODBLite
+ * operates on individual queries. This provides a familiar API but doesn't
+ * provide true ACID guarantees across multiple HTTP requests.
+ */
+export class ODBLiteTransaction {
+  private httpClient: HTTPClient;
+  private isCommitted = false;
+  private isRolledBack = false;
+  private queries: Array<{ sql: string; params: any[] }> = [];
+
+  constructor(httpClient: HTTPClient) {
+    this.httpClient = httpClient;
+  }
+
+  /**
+   * Execute a query within the transaction
+   * For SQLite, we'll queue queries and execute them in batch on commit
+   */
+  async sql<T = any>(sql: TemplateStringsArray, ...values: any[]): Promise<QueryResult<T>> {
+    this.checkTransactionState();
+
+    const parsed = SQLParser.parse(sql, values);
+
+    // For read queries, execute immediately
+    if (this.isReadQuery(parsed.sql)) {
+      return await this.httpClient.query<T>(parsed.sql, parsed.params);
+    }
+
+    // For write queries, queue them for batch execution
+    this.queries.push(parsed);
+
+    // Return a placeholder result for queued queries
+    return {
+      rows: [],
+      rowsAffected: 0,
+      executionTime: 0
+    };
+  }
+
+  /**
+   * Commit the transaction by executing all queued queries
+   */
+  async commit(): Promise<void> {
+    this.checkTransactionState();
+
+    try {
+      // Execute BEGIN
+      await this.httpClient.query('BEGIN');
+
+      // Execute all queued queries
+      for (const query of this.queries) {
+        await this.httpClient.query(query.sql, query.params);
+      }
+
+      // Commit the transaction
+      await this.httpClient.query('COMMIT');
+
+      this.isCommitted = true;
+    } catch (error) {
+      // Rollback on any error
+      try {
+        await this.httpClient.query('ROLLBACK');
+      } catch (rollbackError) {
+        // Ignore rollback errors
+      }
+
+      this.isRolledBack = true;
+      throw new QueryError(
+        `Transaction failed: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        undefined,
+        undefined,
+        error instanceof Error ? error : undefined
+      );
+    }
+  }
+
+  /**
+   * Rollback the transaction
+   */
+  async rollback(): Promise<void> {
+    this.checkTransactionState();
+
+    try {
+      // If we have any queries, we need to actually rollback
+      if (this.queries.length > 0) {
+        await this.httpClient.query('ROLLBACK');
+      }
+    } finally {
+      this.isRolledBack = true;
+    }
+  }
+
+  /**
+   * Check if transaction is still active
+   */
+  private checkTransactionState(): void {
+    if (this.isCommitted) {
+      throw new QueryError('Transaction has already been committed');
+    }
+    if (this.isRolledBack) {
+      throw new QueryError('Transaction has been rolled back');
+    }
+  }
+
+  /**
+   * Determine if a query is a read operation
+   */
+  private isReadQuery(sql: string): boolean {
+    const trimmed = sql.trim().toUpperCase();
+    return trimmed.startsWith('SELECT') ||
+           trimmed.startsWith('WITH') ||
+           trimmed.startsWith('EXPLAIN') ||
+           trimmed.startsWith('PRAGMA');
+  }
+}
+
+/**
+ * Create a simple transaction function that executes immediately
+ * This is more suitable for HTTP-based databases where true transactions
+ * across multiple requests are not practical
+ */
+export function createSimpleTransaction(httpClient: HTTPClient): Transaction {
+  let isActive = true;
+
+  // Create the callable transaction function with context awareness
+  const txFunction = <T = any>(sql: TemplateStringsArray | any, ...values: any[]): Promise<QueryResult<T>> | SQLFragment => {
+    if (!isActive) {
+      throw new QueryError('Transaction is no longer active');
+    }
+
+    // Handle template string queries (returns Promise)
+    if (Array.isArray(sql) && (('raw' in sql) || (typeof sql[0] === 'string' && values.length >= 0))) {
+      const parsed = SQLParser.parse(sql, values);
+      return httpClient.query<T>(parsed.sql, parsed.params);
+    }
+
+    // Handle direct object/array inputs (returns SQLFragment for composing)
+    const parsed = SQLParser.parse(sql, values);
+    return {
+      text: parsed.sql,
+      values: parsed.params
+    };
+  };
+
+  // Attach utility methods to the transaction function
+  txFunction.raw = (text: string): string => SQLParser.raw(text);
+  txFunction.identifier = (name: string): string => SQLParser.identifier(name);
+
+  // Add execute method for compatibility
+  txFunction.execute = async <T = any>(sql: string | { sql: string; args?: any[] }, args?: any[]): Promise<QueryResult<T>> => {
+    if (!isActive) {
+      throw new QueryError('Transaction is no longer active');
+    }
+
+    if (typeof sql === 'string') {
+      return await httpClient.query<T>(sql, args || []);
+    } else {
+      return await httpClient.query<T>(sql.sql, sql.args || []);
+    }
+  };
+
+  // Add query method for compatibility
+  txFunction.query = async <T = any>(sql: string, params: any[] = []): Promise<QueryResult<T>> => {
+    if (!isActive) {
+      throw new QueryError('Transaction is no longer active');
+    }
+    return await httpClient.query<T>(sql, params);
+  };
+
+  txFunction.commit = async (): Promise<void> => {
+    isActive = false;
+    // No-op for simple transactions
+  };
+
+  txFunction.rollback = async (): Promise<void> => {
+    isActive = false;
+    // No-op for simple transactions - individual queries are atomic
+  };
+
+  txFunction.savepoint = async <T = any>(callback: (sql: Transaction) => Promise<T>): Promise<T> => {
+    if (!isActive) {
+      throw new QueryError('Transaction is no longer active');
+    }
+
+    // Create a nested transaction for the savepoint
+    const savepointTx = createSimpleTransaction(httpClient);
+
+    try {
+      // Execute the callback with the savepoint transaction
+      const result = await callback(savepointTx);
+
+      // Commit the savepoint (no-op for simple transactions)
+      await savepointTx.commit();
+
+      return result;
+    } catch (error) {
+      // Rollback the savepoint on error
+      await savepointTx.rollback();
+      throw error;
+    }
+  };
+
+  return txFunction as Transaction;
+}
+
+/**
+ * Simple transaction implementation that executes immediately
+ * This is more suitable for HTTP-based databases where true transactions
+ * across multiple requests are not practical
+ */
+export class SimpleTransaction {
+  private httpClient: HTTPClient;
+  private isActive = true;
+
+  constructor(httpClient: HTTPClient) {
+    this.httpClient = httpClient;
+  }
+
+  async sql<T = any>(sql: TemplateStringsArray, ...values: any[]): Promise<QueryResult<T>> {
+    if (!this.isActive) {
+      throw new QueryError('Transaction is no longer active');
+    }
+
+    const parsed = SQLParser.parse(sql, values);
+    return await this.httpClient.query<T>(parsed.sql, parsed.params);
+  }
+
+  async commit(): Promise<void> {
+    this.isActive = false;
+    // No-op for simple transactions
+  }
+
+  async rollback(): Promise<void> {
+    this.isActive = false;
+    // No-op for simple transactions - individual queries are atomic
+  }
+}

package/src/index.ts

@@ -0,0 +1,51 @@
+// Main entry point for ODB Client
+import { ODBLiteClient } from './core/client.ts';
+
+// Core query client exports (postgres.js-like interface)
+export { ODBLiteClient, odblite } from './core/client.ts';
+export { ODBLiteTransaction, SimpleTransaction } from './core/transaction.ts';
+export { HTTPClient } from './core/http-client.ts';
+export { SQLParser, sql, fragment } from './core/sql-parser.ts';
+
+// Service management exports (high-level tenant database management)
+export { ServiceClient } from './service/service-client.ts';
+
+// Export all types
+export type {
+  ODBLiteConfig,
+  ODBLiteConnection,
+  QueryResult,
+  Transaction,
+  SQLFragment,
+  PreparedQuery,
+  QueryParameter,
+  PrimitiveType,
+  Row
+} from './types.ts';
+
+// Export service client types
+export type {
+  ServiceClientConfig,
+  ODBLiteDatabase,
+  ODBLiteNode
+} from './service/service-client.ts';
+
+// Export error classes
+export {
+  ODBLiteError,
+  ConnectionError,
+  QueryError
+} from './types.ts';
+
+// Export static utility functions for easy access
+export const {
+  raw,
+  identifier,
+  where,
+  insertValues,
+  updateSet,
+  join
+} = ODBLiteClient;
+
+// Default export for convenient usage
+export { odblite as default } from './core/client.ts';