@contractspec/lib.runtime-sandbox 2.7.5 → 2.7.9

package/src/adapters/pglite/adapter.ts

@@ -2,12 +2,12 @@ import { PGlite } from '@electric-sql/pglite';
 
 import type { DatabasePort } from '../../ports/database.port';
 import type {
-  DatabaseInitOptions,
-  DbRow,
-  DbValue,
-  Migration,
-  QueryResult,
-  TransactionContext,
+	DatabaseInitOptions,
+	DbRow,
+	DbValue,
+	Migration,
+	QueryResult,
+	TransactionContext,
 } from '../../types/database.types';
 
 /**
@@ -17,136 +17,136 @@ import type {
  * Supports in-memory or IndexedDB persistence.
  */
 export class PGLiteDatabaseAdapter implements DatabasePort {
-  private client: PGlite | null = null;
-  private initialized = false;
-
-  async init(options?: DatabaseInitOptions): Promise<void> {
-    if (this.initialized) return;
-
-    // Create PGLite instance
-    // - undefined/empty = in-memory
-    // - 'idb://dbname' = IndexedDB persistence
-    const dataDir = options?.dataDir;
-    this.client = dataDir ? new PGlite(`idb://${dataDir}`) : new PGlite();
-
-    // Wait for PGLite to be ready
-    await this.client.waitReady;
-    this.initialized = true;
-  }
-
-  async close(): Promise<void> {
-    if (this.client) {
-      await this.client.close();
-      this.client = null;
-      this.initialized = false;
-    }
-  }
-
-  isInitialized(): boolean {
-    return this.initialized;
-  }
-
-  async query<T = DbRow>(
-    sql: string,
-    params?: DbValue[]
-  ): Promise<QueryResult<T>> {
-    const client = this.getClient();
-    const normalizedParams = this.normalizeParams(params);
-    const result = await client.query<T>(sql, normalizedParams);
-    return {
-      rows: result.rows,
-      rowCount: result.rows.length,
-    };
-  }
-
-  async execute(sql: string, params?: DbValue[]): Promise<void> {
-    const client = this.getClient();
-    const normalizedParams = this.normalizeParams(params);
-    await client.query(sql, normalizedParams);
-  }
-
-  async transaction<T>(
-    callback: (ctx: TransactionContext) => Promise<T>
-  ): Promise<T> {
-    const client = this.getClient();
-
-    await client.query('BEGIN');
-    try {
-      const ctx: TransactionContext = {
-        execute: async (sql: string, params?: DbValue[]) => {
-          const normalizedParams = this.normalizeParams(params);
-          await client.query(sql, normalizedParams);
-        },
-      };
-      const result = await callback(ctx);
-      await client.query('COMMIT');
-      return result;
-    } catch (error) {
-      await client.query('ROLLBACK');
-      throw error;
-    }
-  }
-
-  async migrate(migrations: Migration[]): Promise<void> {
-    const client = this.getClient();
-
-    // Create migrations tracking table if not exists
-    await client.query(`
+	private client: PGlite | null = null;
+	private initialized = false;
+
+	async init(options?: DatabaseInitOptions): Promise<void> {
+		if (this.initialized) return;
+
+		// Create PGLite instance
+		// - undefined/empty = in-memory
+		// - 'idb://dbname' = IndexedDB persistence
+		const dataDir = options?.dataDir;
+		this.client = dataDir ? new PGlite(`idb://${dataDir}`) : new PGlite();
+
+		// Wait for PGLite to be ready
+		await this.client.waitReady;
+		this.initialized = true;
+	}
+
+	async close(): Promise<void> {
+		if (this.client) {
+			await this.client.close();
+			this.client = null;
+			this.initialized = false;
+		}
+	}
+
+	isInitialized(): boolean {
+		return this.initialized;
+	}
+
+	async query<T = DbRow>(
+		sql: string,
+		params?: DbValue[]
+	): Promise<QueryResult<T>> {
+		const client = this.getClient();
+		const normalizedParams = this.normalizeParams(params);
+		const result = await client.query<T>(sql, normalizedParams);
+		return {
+			rows: result.rows,
+			rowCount: result.rows.length,
+		};
+	}
+
+	async execute(sql: string, params?: DbValue[]): Promise<void> {
+		const client = this.getClient();
+		const normalizedParams = this.normalizeParams(params);
+		await client.query(sql, normalizedParams);
+	}
+
+	async transaction<T>(
+		callback: (ctx: TransactionContext) => Promise<T>
+	): Promise<T> {
+		const client = this.getClient();
+
+		await client.query('BEGIN');
+		try {
+			const ctx: TransactionContext = {
+				execute: async (sql: string, params?: DbValue[]) => {
+					const normalizedParams = this.normalizeParams(params);
+					await client.query(sql, normalizedParams);
+				},
+			};
+			const result = await callback(ctx);
+			await client.query('COMMIT');
+			return result;
+		} catch (error) {
+			await client.query('ROLLBACK');
+			throw error;
+		}
+	}
+
+	async migrate(migrations: Migration[]): Promise<void> {
+		const client = this.getClient();
+
+		// Create migrations tracking table if not exists
+		await client.query(`
       CREATE TABLE IF NOT EXISTS _sandbox_migrations (
         id TEXT PRIMARY KEY,
         applied_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
       )
     `);
 
-    // Apply each migration if not already applied
-    for (const migration of migrations) {
-      const existing = await client.query<{ id: string }>(
-        'SELECT id FROM _sandbox_migrations WHERE id = $1',
-        [migration.id]
-      );
-
-      if (existing.rows.length === 0) {
-        await client.query(migration.sql);
-        await client.query('INSERT INTO _sandbox_migrations (id) VALUES ($1)', [
-          migration.id,
-        ]);
-      }
-    }
-  }
-
-  async export(): Promise<Uint8Array> {
-    this.getClient(); // Ensure initialized
-    // PGLite doesn't support export the same way sql.js does
-    // For now, return empty array - can be implemented with pg_dump style later
-    return new Uint8Array();
-  }
-
-  /**
-   * Get the initialized PGLite client.
-   * Throws if not initialized.
-   */
-  private getClient(): PGlite {
-    if (!this.client || !this.initialized) {
-      throw new Error(
-        'PGLiteDatabaseAdapter not initialized. Call init() first.'
-      );
-    }
-    return this.client;
-  }
-
-  private normalizeParams(params?: DbValue[]): unknown[] {
-    if (!params) return [];
-    return params.map((value) => {
-      if (typeof value === 'boolean') {
-        return value;
-      }
-      if (value instanceof Date) {
-        return value.toISOString();
-      }
-      if (value === undefined) {
-        return null;
-      }
-      return value;
-    });
-  }
+		// Apply each migration if not already applied
+		for (const migration of migrations) {
+			const existing = await client.query<{ id: string }>(
+				'SELECT id FROM _sandbox_migrations WHERE id = $1',
+				[migration.id]
+			);
+
+			if (existing.rows.length === 0) {
+				await client.query(migration.sql);
+				await client.query('INSERT INTO _sandbox_migrations (id) VALUES ($1)', [
+					migration.id,
+				]);
+			}
+		}
+	}
+
+	async export(): Promise<Uint8Array> {
+		this.getClient(); // Ensure initialized
+		// PGLite doesn't support export the same way sql.js does
+		// For now, return empty array - can be implemented with pg_dump style later
+		return new Uint8Array();
+	}
+
+	/**
+	 * Get the initialized PGLite client.
+	 * Throws if not initialized.
+	 */
+	private getClient(): PGlite {
+		if (!this.client || !this.initialized) {
+			throw new Error(
+				'PGLiteDatabaseAdapter not initialized. Call init() first.'
+			);
+		}
+		return this.client;
+	}
+
+	private normalizeParams(params?: DbValue[]): unknown[] {
+		if (!params) return [];
+		return params.map((value) => {
+			if (typeof value === 'boolean') {
+				return value;
+			}
+			if (value instanceof Date) {
+				return value.toISOString();
+			}
+			if (value === undefined) {
+				return null;
+			}
+			return value;
+		});
+	}
 }

package/src/index.ts

@@ -10,12 +10,12 @@ export { type DatabaseAdapterFactory, type DatabasePort } from './ports';
 
 // Types
 export {
-  type DatabaseInitOptions,
-  type DbRow,
-  type DbValue,
-  type Migration,
-  type QueryResult,
-  type TransactionContext,
+	type DatabaseInitOptions,
+	type DbRow,
+	type DbValue,
+	type Migration,
+	type QueryResult,
+	type TransactionContext,
 } from './types';
 
 /**
@@ -32,10 +32,10 @@ export {
  * ```
  */
 export async function createPGLiteAdapter(): Promise<
-  import('./ports').DatabasePort
+	import('./ports').DatabasePort
 > {
-  const { PGLiteDatabaseAdapter } = await import('./adapters/pglite');
-  return new PGLiteDatabaseAdapter();
+	const { PGLiteDatabaseAdapter } = await import('./adapters/pglite');
+	return new PGLiteDatabaseAdapter();
 }
 
 export * as web from './web';

package/src/ports/database.port.ts

@@ -1,10 +1,10 @@
 import type {
-  DatabaseInitOptions,
-  DbRow,
-  DbValue,
-  Migration,
-  QueryResult,
-  TransactionContext,
+	DatabaseInitOptions,
+	DbRow,
+	DbValue,
+	Migration,
+	QueryResult,
+	TransactionContext,
 } from '../types/database.types';
 
 /**
@@ -18,59 +18,59 @@ import type {
  * All implementations must be lazy-loadable to avoid bundle bloat.
  */
 export interface DatabasePort {
-  /**
-   * Initialize the database connection and run migrations.
-   */
-  init(options?: DatabaseInitOptions): Promise<void>;
+	/**
+	 * Initialize the database connection and run migrations.
+	 */
+	init(options?: DatabaseInitOptions): Promise<void>;
 
-  /**
-   * Close the database connection and release resources.
-   */
-  close(): Promise<void>;
+	/**
+	 * Close the database connection and release resources.
+	 */
+	close(): Promise<void>;
 
-  /**
-   * Check if the database is initialized.
-   */
-  isInitialized(): boolean;
+	/**
+	 * Check if the database is initialized.
+	 */
+	isInitialized(): boolean;
 
-  /**
-   * Execute a SELECT query and return rows.
-   *
-   * @param sql - SQL query string with $1, $2, etc. placeholders
-   * @param params - Query parameters
-   * @returns Query result with typed rows
-   */
-  query<T = DbRow>(sql: string, params?: DbValue[]): Promise<QueryResult<T>>;
+	/**
+	 * Execute a SELECT query and return rows.
+	 *
+	 * @param sql - SQL query string with $1, $2, etc. placeholders
+	 * @param params - Query parameters
+	 * @returns Query result with typed rows
+	 */
+	query<T = DbRow>(sql: string, params?: DbValue[]): Promise<QueryResult<T>>;
 
-  /**
-   * Execute an INSERT/UPDATE/DELETE statement.
-   *
-   * @param sql - SQL statement with $1, $2, etc. placeholders
-   * @param params - Statement parameters
-   */
-  execute(sql: string, params?: DbValue[]): Promise<void>;
+	/**
+	 * Execute an INSERT/UPDATE/DELETE statement.
+	 *
+	 * @param sql - SQL statement with $1, $2, etc. placeholders
+	 * @param params - Statement parameters
+	 */
+	execute(sql: string, params?: DbValue[]): Promise<void>;
 
-  /**
-   * Run a callback within a database transaction.
-   * Automatically commits on success, rolls back on error.
-   *
-   * @param callback - Function to execute within transaction
-   * @returns Result of the callback
-   */
-  transaction<T>(callback: (ctx: TransactionContext) => Promise<T>): Promise<T>;
+	/**
+	 * Run a callback within a database transaction.
+	 * Automatically commits on success, rolls back on error.
+	 *
+	 * @param callback - Function to execute within transaction
+	 * @returns Result of the callback
+	 */
+	transaction<T>(callback: (ctx: TransactionContext) => Promise<T>): Promise<T>;
 
-  /**
-   * Run schema migrations.
-   *
-   * @param migrations - Array of migrations to apply
-   */
-  migrate(migrations: Migration[]): Promise<void>;
+	/**
+	 * Run schema migrations.
+	 *
+	 * @param migrations - Array of migrations to apply
+	 */
+	migrate(migrations: Migration[]): Promise<void>;
 
-  /**
-   * Export the current database state as a binary blob.
-   * Useful for backup/restore in browser context.
-   */
-  export(): Promise<Uint8Array>;
+	/**
+	 * Export the current database state as a binary blob.
+	 * Useful for backup/restore in browser context.
+	 */
+	export(): Promise<Uint8Array>;
 }
 
 /**
@@ -78,5 +78,5 @@ export interface DatabasePort {
  * Used for lazy-loading adapters.
  */
 export type DatabaseAdapterFactory = (
-  options?: DatabaseInitOptions
+	options?: DatabaseInitOptions
 ) => Promise<DatabasePort>;

package/src/ports/index.ts

@@ -1,4 +1,4 @@
 export {
-  type DatabaseAdapterFactory,
-  type DatabasePort,
+	type DatabaseAdapterFactory,
+	type DatabasePort,
 } from './database.port';

package/src/types/database.types.ts

@@ -2,13 +2,13 @@
  * Database value types supported by the sandbox runtime
  */
 export type DbValue =
-  | string
-  | number
-  | boolean
-  | null
-  | Uint8Array
-  | Date
-  | undefined;
+	| string
+	| number
+	| boolean
+	| null
+	| Uint8Array
+	| Date
+	| undefined;
 
 /**
  * Generic row type for database results
@@ -19,37 +19,37 @@ export type DbRow = Record<string, DbValue>;
  * Options for initializing a database adapter
  */
 export interface DatabaseInitOptions {
-  /**
-   * Data directory for persistence (optional).
-   * - Browser: uses IndexedDB when specified
-   * - Node/Bun: uses file system when specified
-   * - If omitted, uses in-memory storage
-   */
-  dataDir?: string;
+	/**
+	 * Data directory for persistence (optional).
+	 * - Browser: uses IndexedDB when specified
+	 * - Node/Bun: uses file system when specified
+	 * - If omitted, uses in-memory storage
+	 */
+	dataDir?: string;
 }
 
 /**
  * Query builder result type
  */
 export interface QueryResult<T = DbRow> {
-  rows: T[];
-  rowCount: number;
+	rows: T[];
+	rowCount: number;
 }
 
 /**
  * Transaction context for atomic operations
  */
 export interface TransactionContext {
-  /**
-   * Execute raw SQL within the transaction
-   */
-  execute(sql: string, params?: DbValue[]): Promise<void>;
+	/**
+	 * Execute raw SQL within the transaction
+	 */
+	execute(sql: string, params?: DbValue[]): Promise<void>;
 }
 
 /**
  * Migration definition
  */
 export interface Migration {
-  id: string;
-  sql: string;
+	id: string;
+	sql: string;
 }