@parsrun/database 0.1.0

package/dist/adapters/postgres.js

@@ -0,0 +1,165 @@
+// src/adapters/postgres.ts
+import { drizzle } from "drizzle-orm/postgres-js";
+
+// src/types.ts
+var DatabaseError = class extends Error {
+  constructor(message, code, cause) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+    this.name = "DatabaseError";
+  }
+};
+var DatabaseErrorCodes = {
+  CONNECTION_FAILED: "CONNECTION_FAILED",
+  QUERY_FAILED: "QUERY_FAILED",
+  TRANSACTION_FAILED: "TRANSACTION_FAILED",
+  MIGRATION_FAILED: "MIGRATION_FAILED",
+  INVALID_CONFIG: "INVALID_CONFIG",
+  ADAPTER_NOT_AVAILABLE: "ADAPTER_NOT_AVAILABLE",
+  TIMEOUT: "TIMEOUT",
+  CONSTRAINT_VIOLATION: "CONSTRAINT_VIOLATION",
+  NOT_FOUND: "NOT_FOUND"
+};
+
+// src/adapters/postgres.ts
+var PostgresAdapter = class {
+  type = "postgres";
+  client = null;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  db = null;
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Initialize the connection
+   */
+  async connect() {
+    if (this.client) return;
+    try {
+      const postgresModule = await import("postgres");
+      const postgres = postgresModule.default;
+      let sslConfig = false;
+      if (this.config.ssl === true) {
+        sslConfig = "require";
+      } else if (typeof this.config.ssl === "object") {
+        sslConfig = this.config.ssl;
+      }
+      this.client = postgres({
+        host: this.config.host,
+        port: this.config.port,
+        user: this.config.user,
+        password: this.config.password,
+        database: this.config.database,
+        ssl: sslConfig,
+        max: this.config.poolSize ?? 10
+      });
+      const drizzleOpts = {};
+      if (this.config.logging !== void 0) {
+        drizzleOpts.logger = this.config.logging;
+      }
+      this.db = drizzle(this.client, drizzleOpts);
+    } catch (err) {
+      throw new DatabaseError(
+        `Failed to connect to PostgreSQL: ${err instanceof Error ? err.message : "Unknown error"}`,
+        DatabaseErrorCodes.CONNECTION_FAILED,
+        err
+      );
+    }
+  }
+  async execute(sql) {
+    if (!this.client) {
+      await this.connect();
+    }
+    try {
+      const client = this.client;
+      const result = await client.unsafe(sql);
+      return result;
+    } catch (err) {
+      throw new DatabaseError(
+        `Query failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+        DatabaseErrorCodes.QUERY_FAILED,
+        err
+      );
+    }
+  }
+  async ping() {
+    try {
+      await this.execute("SELECT 1");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async health() {
+    const start = Date.now();
+    try {
+      if (!this.client) {
+        await this.connect();
+      }
+      const result = await this.execute("SELECT version()");
+      const latencyMs = Date.now() - start;
+      return {
+        healthy: true,
+        latencyMs,
+        version: result[0]?.version
+      };
+    } catch (err) {
+      return {
+        healthy: false,
+        latencyMs: Date.now() - start,
+        error: err instanceof Error ? err.message : "Unknown error"
+      };
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  drizzle() {
+    if (!this.db) {
+      throw new DatabaseError(
+        "Database not connected. Call connect() first.",
+        DatabaseErrorCodes.CONNECTION_FAILED
+      );
+    }
+    return this.db;
+  }
+  async close() {
+    if (this.client) {
+      const client = this.client;
+      await client.end();
+      this.client = null;
+      this.db = null;
+    }
+  }
+  /**
+   * Get the raw postgres client
+   */
+  getClient() {
+    return this.client;
+  }
+};
+async function createPostgresAdapter(config) {
+  const adapter = new PostgresAdapter(config);
+  await adapter.connect();
+  return adapter;
+}
+async function createPostgresFromUrl(connectionString, options) {
+  const url = new URL(connectionString);
+  const config = {
+    type: "postgres",
+    host: url.hostname,
+    port: parseInt(url.port || "5432", 10),
+    user: url.username,
+    password: url.password,
+    database: url.pathname.slice(1),
+    ssl: url.searchParams.get("sslmode") === "require",
+    ...options
+  };
+  return createPostgresAdapter(config);
+}
+export {
+  PostgresAdapter,
+  createPostgresAdapter,
+  createPostgresFromUrl
+};
+//# sourceMappingURL=postgres.js.map

package/dist/adapters/postgres.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapters/postgres.ts","../../src/types.ts"],"sourcesContent":["/**\n * @parsrun/database - PostgreSQL Adapter\n * PostgreSQL adapter using postgres.js\n */\n\nimport { drizzle, type PostgresJsDatabase } from \"drizzle-orm/postgres-js\";\nimport type {\n  DatabaseAdapter,\n  DatabaseHealth,\n  PostgresConfig,\n} from \"../types.js\";\nimport { DatabaseError, DatabaseErrorCodes } from \"../types.js\";\n\n/**\n * PostgreSQL Database Adapter\n *\n * @example\n * ```typescript\n * const db = await createPostgresAdapter({\n *   type: 'postgres',\n *   host: 'localhost',\n *   port: 5432,\n *   user: 'postgres',\n *   password: 'password',\n *   database: 'mydb',\n * });\n *\n * // Execute queries\n * const users = await db.drizzle().select().from(usersTable);\n *\n * // Close when done\n * await db.close();\n * ```\n */\nexport class PostgresAdapter implements DatabaseAdapter {\n  readonly type = \"postgres\" as const;\n\n  private client: unknown = null;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private db: PostgresJsDatabase<any> | null = null;\n  private config: PostgresConfig;\n\n  constructor(config: PostgresConfig) {\n    this.config = config;\n  }\n\n  /**\n   * Initialize the connection\n   */\n  async connect(): Promise<void> {\n    if (this.client) return;\n\n    try {\n      const postgresModule = await import(\"postgres\");\n      const postgres = postgresModule.default;\n\n      // Build SSL config\n      type SSLMode = boolean | \"require\" | \"allow\" | \"prefer\" | \"verify-full\" | { rejectUnauthorized: boolean };\n      let sslConfig: SSLMode = false;\n\n      if (this.config.ssl === true) {\n        sslConfig = \"require\";\n      } else if (typeof this.config.ssl === \"object\") {\n        sslConfig = this.config.ssl;\n      }\n\n      this.client = postgres({\n        host: this.config.host,\n        port: this.config.port,\n        user: this.config.user,\n        password: this.config.password,\n        database: this.config.database,\n        ssl: sslConfig,\n        max: this.config.poolSize ?? 10,\n      });\n\n      // Build drizzle config - use any to avoid complex type issues\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      const drizzleOpts: any = {};\n      if (this.config.logging !== undefined) {\n        drizzleOpts.logger = this.config.logging;\n      }\n\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      this.db = drizzle(this.client as any, drizzleOpts);\n    } catch (err) {\n      throw new DatabaseError(\n        `Failed to connect to PostgreSQL: ${err instanceof Error ? err.message : \"Unknown error\"}`,\n        DatabaseErrorCodes.CONNECTION_FAILED,\n        err\n      );\n    }\n  }\n\n  async execute<T = unknown>(sql: string): Promise<T[]> {\n    if (!this.client) {\n      await this.connect();\n    }\n\n    try {\n      const client = this.client as { unsafe: (sql: string) => Promise<unknown[]> };\n      const result = await client.unsafe(sql);\n      return result as T[];\n    } catch (err) {\n      throw new DatabaseError(\n        `Query failed: ${err instanceof Error ? err.message : \"Unknown error\"}`,\n        DatabaseErrorCodes.QUERY_FAILED,\n        err\n      );\n    }\n  }\n\n  async ping(): Promise<boolean> {\n    try {\n      await this.execute(\"SELECT 1\");\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  async health(): Promise<DatabaseHealth> {\n    const start = Date.now();\n\n    try {\n      if (!this.client) {\n        await this.connect();\n      }\n\n      const result = await this.execute<{ version: string }>(\"SELECT version()\");\n      const latencyMs = Date.now() - start;\n\n      return {\n        healthy: true,\n        latencyMs,\n        version: result[0]?.version,\n      };\n    } catch (err) {\n      return {\n        healthy: false,\n        latencyMs: Date.now() - start,\n        error: err instanceof Error ? err.message : \"Unknown error\",\n      };\n    }\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  drizzle(): PostgresJsDatabase<any> {\n    if (!this.db) {\n      throw new DatabaseError(\n        \"Database not connected. Call connect() first.\",\n        DatabaseErrorCodes.CONNECTION_FAILED\n      );\n    }\n    return this.db;\n  }\n\n  async close(): Promise<void> {\n    if (this.client) {\n      const client = this.client as { end: () => Promise<void> };\n      await client.end();\n      this.client = null;\n      this.db = null;\n    }\n  }\n\n  /**\n   * Get the raw postgres client\n   */\n  getClient(): unknown {\n    return this.client;\n  }\n}\n\n/**\n * Create a PostgreSQL adapter\n */\nexport async function createPostgresAdapter(\n  config: PostgresConfig\n): Promise<PostgresAdapter> {\n  const adapter = new PostgresAdapter(config);\n  await adapter.connect();\n  return adapter;\n}\n\n/**\n * Create a PostgreSQL adapter from connection string\n */\nexport async function createPostgresFromUrl(\n  connectionString: string,\n  options?: Omit<PostgresConfig, \"type\" | \"host\" | \"port\" | \"user\" | \"password\" | \"database\">\n): Promise<PostgresAdapter> {\n  const url = new URL(connectionString);\n\n  const config: PostgresConfig = {\n    type: \"postgres\",\n    host: url.hostname,\n    port: parseInt(url.port || \"5432\", 10),\n    user: url.username,\n    password: url.password,\n    database: url.pathname.slice(1),\n    ssl: url.searchParams.get(\"sslmode\") === \"require\",\n    ...options,\n  };\n\n  return createPostgresAdapter(config);\n}\n","/**\n * @parsrun/database - Type Definitions\n * Database types and interfaces\n */\n\n/**\n * Database adapter type\n */\nexport type DatabaseAdapterType = \"postgres\" | \"neon\" | \"d1\" | \"custom\";\n\n/**\n * Base database configuration\n */\nexport interface BaseDatabaseConfig {\n  /** Adapter type */\n  type: DatabaseAdapterType;\n  /** Enable query logging */\n  logging?: boolean | undefined;\n  /** Connection pool size */\n  poolSize?: number | undefined;\n}\n\n/**\n * PostgreSQL configuration\n */\nexport interface PostgresConfig extends BaseDatabaseConfig {\n  type: \"postgres\";\n  /** Database host */\n  host: string;\n  /** Database port */\n  port: number;\n  /** Database user */\n  user: string;\n  /** Database password */\n  password: string;\n  /** Database name */\n  database: string;\n  /** SSL configuration */\n  ssl?: boolean | { rejectUnauthorized: boolean } | undefined;\n}\n\n/**\n * Neon serverless configuration\n */\nexport interface NeonConfig extends BaseDatabaseConfig {\n  type: \"neon\";\n  /** Connection string */\n  connectionString: string;\n  /** Use pooled connection */\n  pooled?: boolean | undefined;\n}\n\n/**\n * Cloudflare D1 configuration\n */\nexport interface D1Config extends BaseDatabaseConfig {\n  type: \"d1\";\n  /** D1 binding */\n  binding: D1Database;\n}\n\n/**\n * Cloudflare D1 Database binding type\n */\nexport interface D1Database {\n  prepare(query: string): D1PreparedStatement;\n  batch<T>(statements: D1PreparedStatement[]): Promise<D1Result<T>[]>;\n  dump(): Promise<ArrayBuffer>;\n  exec<T>(query: string): Promise<D1Result<T>>;\n}\n\ninterface D1PreparedStatement {\n  bind(...values: unknown[]): D1PreparedStatement;\n  first<T = unknown>(column?: string): Promise<T | null>;\n  run<T = unknown>(): Promise<D1Result<T>>;\n  all<T = unknown>(): Promise<D1Result<T>>;\n  raw<T = unknown>(): Promise<T[]>;\n}\n\ninterface D1Result<T> {\n  results?: T[];\n  success: boolean;\n  error?: string;\n  meta?: D1Meta;\n}\n\ninterface D1Meta {\n  duration: number;\n  rows_read: number;\n  rows_written: number;\n}\n\n/**\n * Combined database configuration\n */\nexport type DatabaseConfig = PostgresConfig | NeonConfig | D1Config;\n\n/**\n * Migration status\n */\nexport interface MigrationStatus {\n  /** Whether migrations need to be run */\n  needsMigration: boolean;\n  /** Whether database is up to date */\n  upToDate: boolean;\n  /** Number of pending migrations */\n  pendingCount: number;\n  /** Number of applied migrations */\n  appliedCount: number;\n  /** Error message if check failed */\n  error?: string | undefined;\n}\n\n/**\n * Migration result\n */\nexport interface MigrationResult {\n  /** Whether migration succeeded */\n  success: boolean;\n  /** Number of migrations applied */\n  appliedCount?: number | undefined;\n  /** Error message if migration failed */\n  error?: string | undefined;\n}\n\n/**\n * Transaction options\n */\nexport interface TransactionOptions {\n  /** Isolation level */\n  isolationLevel?: \"read uncommitted\" | \"read committed\" | \"repeatable read\" | \"serializable\" | undefined;\n  /** Access mode */\n  accessMode?: \"read only\" | \"read write\" | undefined;\n  /** Deferrable (PostgreSQL) */\n  deferrable?: boolean | undefined;\n}\n\n/**\n * Query options\n */\nexport interface QueryOptions {\n  /** Query timeout in milliseconds */\n  timeout?: number | undefined;\n  /** Transform result rows */\n  transform?: \"camelCase\" | \"snakeCase\" | undefined;\n}\n\n/**\n * Database health status\n */\nexport interface DatabaseHealth {\n  /** Whether database is healthy */\n  healthy: boolean;\n  /** Connection latency in milliseconds */\n  latencyMs: number;\n  /** Database version */\n  version?: string | undefined;\n  /** Error message if unhealthy */\n  error?: string | undefined;\n}\n\n/**\n * Database adapter interface\n */\nexport interface DatabaseAdapter {\n  /** Adapter type */\n  readonly type: DatabaseAdapterType;\n\n  /**\n   * Execute raw SQL query\n   */\n  execute<T = unknown>(sql: string): Promise<T[]>;\n\n  /**\n   * Check connection health\n   */\n  ping(): Promise<boolean>;\n\n  /**\n   * Get connection health with details\n   */\n  health(): Promise<DatabaseHealth>;\n\n  /**\n   * Get the underlying Drizzle instance\n   */\n  drizzle(): unknown;\n\n  /**\n   * Close database connection\n   */\n  close(): Promise<void>;\n}\n\n/**\n * Database error\n */\nexport class DatabaseError extends Error {\n  constructor(\n    message: string,\n    public readonly code: string,\n    public readonly cause?: unknown\n  ) {\n    super(message);\n    this.name = \"DatabaseError\";\n  }\n}\n\n/**\n * Common database error codes\n */\nexport const DatabaseErrorCodes = {\n  CONNECTION_FAILED: \"CONNECTION_FAILED\",\n  QUERY_FAILED: \"QUERY_FAILED\",\n  TRANSACTION_FAILED: \"TRANSACTION_FAILED\",\n  MIGRATION_FAILED: \"MIGRATION_FAILED\",\n  INVALID_CONFIG: \"INVALID_CONFIG\",\n  ADAPTER_NOT_AVAILABLE: \"ADAPTER_NOT_AVAILABLE\",\n  TIMEOUT: \"TIMEOUT\",\n  CONSTRAINT_VIOLATION: \"CONSTRAINT_VIOLATION\",\n  NOT_FOUND: \"NOT_FOUND\",\n} as const;\n"],"mappings":"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","names":[]}

package/dist/index.d.ts

@@ -0,0 +1,177 @@
+import { D as DatabaseConfig, a as DatabaseAdapter } from './types-DgBIyTeZ.js';
+export { B as BaseDatabaseConfig, c as D1Config, d as D1Database, b as DatabaseAdapterType, g as DatabaseError, h as DatabaseErrorCodes, f as DatabaseHealth, e as MigrationResult, M as MigrationStatus, N as NeonConfig, P as PostgresConfig, Q as QueryOptions, T as TransactionOptions } from './types-DgBIyTeZ.js';
+export { PostgresAdapter, createPostgresAdapter, createPostgresFromUrl } from './adapters/postgres.js';
+export { NeonAdapter, createNeonAdapter, createNeonFromUrl } from './adapters/neon.js';
+export { D1Adapter, createD1Adapter } from './adapters/d1.js';
+export * from 'drizzle-orm';
+import 'drizzle-orm/postgres-js';
+import '@neondatabase/serverless';
+import 'drizzle-orm/d1';
+
+/**
+ * @parsrun/database - Utilities
+ * Database utility functions
+ */
+/**
+ * Sleep for specified milliseconds
+ */
+declare function sleep(ms: number): Promise<void>;
+/**
+ * Retry a database operation with exponential backoff
+ */
+declare function retry<T>(operation: () => Promise<T>, options?: {
+    maxAttempts?: number;
+    baseDelay?: number;
+    maxDelay?: number;
+    shouldRetry?: (error: unknown) => boolean;
+}): Promise<T>;
+/**
+ * Check if an error is retryable
+ */
+declare function isRetryableError(error: unknown): boolean;
+/**
+ * Parse a PostgreSQL connection string
+ */
+declare function parseConnectionString(connectionString: string): {
+    host: string;
+    port: number;
+    user: string;
+    password: string;
+    database: string;
+    ssl: boolean;
+    params: Record<string, string>;
+};
+/**
+ * Build a PostgreSQL connection string
+ */
+declare function buildConnectionString(config: {
+    host: string;
+    port?: number;
+    user: string;
+    password: string;
+    database: string;
+    ssl?: boolean;
+    params?: Record<string, string>;
+}): string;
+/**
+ * Convert snake_case to camelCase
+ */
+declare function snakeToCamel(str: string): string;
+/**
+ * Convert camelCase to snake_case
+ */
+declare function camelToSnake(str: string): string;
+/**
+ * Transform object keys from snake_case to camelCase
+ */
+declare function transformToCamelCase<T extends Record<string, unknown>>(obj: T): Record<string, unknown>;
+/**
+ * Transform object keys from camelCase to snake_case
+ */
+declare function transformToSnakeCase<T extends Record<string, unknown>>(obj: T): Record<string, unknown>;
+/**
+ * Generate a UUID v4
+ */
+declare function generateUUID(): string;
+/**
+ * Generate a short ID (8 characters)
+ */
+declare function generateShortId(): string;
+/**
+ * Paginate results
+ */
+interface PaginationOptions {
+    page?: number;
+    limit?: number;
+    maxLimit?: number;
+}
+interface PaginatedResult<T> {
+    data: T[];
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+        totalPages: number;
+        hasMore: boolean;
+    };
+}
+/**
+ * Calculate pagination offset
+ */
+declare function getPaginationOffset(options: PaginationOptions): {
+    offset: number;
+    limit: number;
+};
+/**
+ * Create paginated result
+ */
+declare function createPaginatedResult<T>(data: T[], total: number, options: PaginationOptions): PaginatedResult<T>;
+/**
+ * Escape special characters for LIKE queries
+ */
+declare function escapeLike(value: string): string;
+/**
+ * Build a search pattern for LIKE queries
+ */
+declare function buildSearchPattern(value: string, mode?: "contains" | "startsWith" | "endsWith"): string;
+
+/**
+ * @parsrun/database
+ * Database utilities for Pars - Drizzle ORM helpers, multi-runtime support
+ *
+ * Supports:
+ * - PostgreSQL (via postgres.js)
+ * - Neon Serverless (edge-compatible)
+ * - Cloudflare D1 (SQLite)
+ *
+ * @example
+ * ```typescript
+ * import { createDatabase } from '@parsrun/database';
+ *
+ * // PostgreSQL
+ * const db = await createDatabase({
+ *   type: 'postgres',
+ *   host: 'localhost',
+ *   port: 5432,
+ *   user: 'postgres',
+ *   password: 'password',
+ *   database: 'mydb',
+ * });
+ *
+ * // Neon Serverless
+ * const db = await createDatabase({
+ *   type: 'neon',
+ *   connectionString: process.env.DATABASE_URL,
+ * });
+ *
+ * // Cloudflare D1
+ * const db = createDatabase({
+ *   type: 'd1',
+ *   binding: env.DB,
+ * });
+ *
+ * // Use with Drizzle ORM
+ * const users = await db.drizzle().select().from(usersTable);
+ * ```
+ */
+
+/**
+ * Create a database adapter based on configuration
+ *
+ * @param config - Database configuration
+ * @returns Database adapter instance
+ */
+declare function createDatabase(config: DatabaseConfig): Promise<DatabaseAdapter>;
+/**
+ * Create a database adapter from connection string
+ *
+ * @param connectionString - Database connection URL
+ * @param options - Additional options
+ * @returns Database adapter instance
+ */
+declare function createDatabaseFromUrl(connectionString: string, options?: {
+    logging?: boolean;
+    poolSize?: number;
+}): Promise<DatabaseAdapter>;
+
+export { DatabaseAdapter, DatabaseConfig, type PaginatedResult, type PaginationOptions, buildConnectionString, buildSearchPattern, camelToSnake, createDatabase, createDatabaseFromUrl, createPaginatedResult, escapeLike, generateShortId, generateUUID, getPaginationOffset, isRetryableError, parseConnectionString, retry, sleep, snakeToCamel, transformToCamelCase, transformToSnakeCase };