@parsrun/database 0.1.0

package/dist/index.js

@@ -0,0 +1,651 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/types.ts
+var DatabaseError, DatabaseErrorCodes;
+var init_types = __esm({
+  "src/types.ts"() {
+    "use strict";
+    DatabaseError = class extends Error {
+      constructor(message, code, cause) {
+        super(message);
+        this.code = code;
+        this.cause = cause;
+        this.name = "DatabaseError";
+      }
+    };
+    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 postgres_exports = {};
+__export(postgres_exports, {
+  PostgresAdapter: () => PostgresAdapter,
+  createPostgresAdapter: () => createPostgresAdapter,
+  createPostgresFromUrl: () => createPostgresFromUrl
+});
+import { drizzle } from "drizzle-orm/postgres-js";
+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);
+}
+var PostgresAdapter;
+var init_postgres = __esm({
+  "src/adapters/postgres.ts"() {
+    "use strict";
+    init_types();
+    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;
+      }
+    };
+  }
+});
+
+// src/adapters/neon.ts
+var neon_exports = {};
+__export(neon_exports, {
+  NeonAdapter: () => NeonAdapter,
+  createNeonAdapter: () => createNeonAdapter,
+  createNeonFromUrl: () => createNeonFromUrl
+});
+import { drizzle as drizzle2 } from "drizzle-orm/neon-http";
+async function createNeonAdapter(config) {
+  const adapter = new NeonAdapter(config);
+  await adapter.connect();
+  return adapter;
+}
+async function createNeonFromUrl(connectionString, options) {
+  return createNeonAdapter({
+    type: "neon",
+    connectionString,
+    ...options
+  });
+}
+var NeonAdapter;
+var init_neon = __esm({
+  "src/adapters/neon.ts"() {
+    "use strict";
+    init_types();
+    NeonAdapter = class {
+      type = "neon";
+      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 { neon } = await import("@neondatabase/serverless");
+          this.client = neon(this.config.connectionString, {
+            fetchOptions: {
+              cache: "no-store"
+            }
+          });
+          const drizzleOpts = {};
+          if (this.config.logging !== void 0) {
+            drizzleOpts.logger = this.config.logging;
+          }
+          this.db = drizzle2(this.client, drizzleOpts);
+        } catch (err) {
+          throw new DatabaseError(
+            `Failed to connect to Neon: ${err instanceof Error ? err.message : "Unknown error"}`,
+            DatabaseErrorCodes.CONNECTION_FAILED,
+            err
+          );
+        }
+      }
+      async execute(sql) {
+        if (!this.client) {
+          await this.connect();
+        }
+        try {
+          const result = await this.client(sql);
+          if (Array.isArray(result) && result.rows) {
+            return result.rows;
+          }
+          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() {
+        this.client = null;
+        this.db = null;
+      }
+      /**
+       * Get the raw Neon client
+       */
+      getClient() {
+        return this.client;
+      }
+    };
+  }
+});
+
+// src/adapters/d1.ts
+var d1_exports = {};
+__export(d1_exports, {
+  D1Adapter: () => D1Adapter,
+  createD1Adapter: () => createD1Adapter
+});
+import { drizzle as drizzle3 } from "drizzle-orm/d1";
+function createD1Adapter(config) {
+  return new D1Adapter(config);
+}
+var D1Adapter;
+var init_d1 = __esm({
+  "src/adapters/d1.ts"() {
+    "use strict";
+    init_types();
+    D1Adapter = class {
+      type = "d1";
+      binding;
+      db;
+      constructor(config) {
+        this.binding = config.binding;
+        const drizzleConfig = {};
+        if (config.logging !== void 0) {
+          drizzleConfig.logger = config.logging;
+        }
+        this.db = drizzle3(this.binding, drizzleConfig);
+      }
+      async execute(sql) {
+        try {
+          const result = await this.binding.exec(sql);
+          return result.results ?? [];
+        } catch (err) {
+          throw new DatabaseError(
+            `Query failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+            DatabaseErrorCodes.QUERY_FAILED,
+            err
+          );
+        }
+      }
+      async ping() {
+        try {
+          await this.binding.prepare("SELECT 1").first();
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      async health() {
+        const start = Date.now();
+        try {
+          await this.binding.prepare("SELECT 1").first();
+          const latencyMs = Date.now() - start;
+          const versionResult = await this.binding.prepare("SELECT sqlite_version() as version").first();
+          return {
+            healthy: true,
+            latencyMs,
+            version: versionResult ? `SQLite ${versionResult.version}` : void 0
+          };
+        } catch (err) {
+          return {
+            healthy: false,
+            latencyMs: Date.now() - start,
+            error: err instanceof Error ? err.message : "Unknown error"
+          };
+        }
+      }
+      drizzle() {
+        return this.db;
+      }
+      async close() {
+      }
+      /**
+       * Get the raw D1 binding
+       */
+      getBinding() {
+        return this.binding;
+      }
+      /**
+       * Execute a batch of statements
+       */
+      async batch(statements) {
+        try {
+          const prepared = statements.map((stmt) => {
+            const p = this.binding.prepare(stmt.sql);
+            return stmt.params ? p.bind(...stmt.params) : p;
+          });
+          const results = await this.binding.batch(prepared);
+          return results.map((r) => r.results ?? []);
+        } catch (err) {
+          throw new DatabaseError(
+            `Batch execution failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+            DatabaseErrorCodes.QUERY_FAILED,
+            err
+          );
+        }
+      }
+    };
+  }
+});
+
+// src/index.ts
+init_types();
+init_postgres();
+init_neon();
+init_d1();
+
+// src/utils.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function retry(operation, options = {}) {
+  const {
+    maxAttempts = 3,
+    baseDelay = 100,
+    maxDelay = 5e3,
+    shouldRetry = isRetryableError
+  } = options;
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await operation();
+    } catch (error) {
+      lastError = error;
+      if (attempt === maxAttempts || !shouldRetry(error)) {
+        throw error;
+      }
+      const delay = Math.min(baseDelay * Math.pow(2, attempt - 1), maxDelay);
+      await sleep(delay);
+    }
+  }
+  throw lastError;
+}
+function isRetryableError(error) {
+  if (error instanceof Error) {
+    const message = error.message.toLowerCase();
+    if (message.includes("connection") || message.includes("econnrefused") || message.includes("econnreset") || message.includes("etimedout")) {
+      return true;
+    }
+    if (message.includes("could not serialize") || message.includes("deadlock detected")) {
+      return true;
+    }
+    if (message.includes("too many clients")) {
+      return true;
+    }
+  }
+  return false;
+}
+function parseConnectionString(connectionString) {
+  const url = new URL(connectionString);
+  const params = {};
+  url.searchParams.forEach((value, key) => {
+    params[key] = value;
+  });
+  return {
+    host: url.hostname,
+    port: parseInt(url.port || "5432", 10),
+    user: decodeURIComponent(url.username),
+    password: decodeURIComponent(url.password),
+    database: url.pathname.slice(1),
+    ssl: url.searchParams.get("sslmode") === "require" || url.searchParams.get("ssl") === "true",
+    params
+  };
+}
+function buildConnectionString(config) {
+  const url = new URL(`postgresql://${config.host}`);
+  url.port = String(config.port ?? 5432);
+  url.username = encodeURIComponent(config.user);
+  url.password = encodeURIComponent(config.password);
+  url.pathname = `/${config.database}`;
+  if (config.ssl) {
+    url.searchParams.set("sslmode", "require");
+  }
+  if (config.params) {
+    for (const [key, value] of Object.entries(config.params)) {
+      url.searchParams.set(key, value);
+    }
+  }
+  return url.toString();
+}
+function snakeToCamel(str) {
+  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function camelToSnake(str) {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function transformToCamelCase(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const newKey = snakeToCamel(key);
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      result[newKey] = transformToCamelCase(value);
+    } else if (Array.isArray(value)) {
+      result[newKey] = value.map(
+        (item) => item && typeof item === "object" ? transformToCamelCase(item) : item
+      );
+    } else {
+      result[newKey] = value;
+    }
+  }
+  return result;
+}
+function transformToSnakeCase(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const newKey = camelToSnake(key);
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      result[newKey] = transformToSnakeCase(value);
+    } else if (Array.isArray(value)) {
+      result[newKey] = value.map(
+        (item) => item && typeof item === "object" ? transformToSnakeCase(item) : item
+      );
+    } else {
+      result[newKey] = value;
+    }
+  }
+  return result;
+}
+function generateUUID() {
+  return crypto.randomUUID();
+}
+function generateShortId() {
+  return crypto.randomUUID().slice(0, 8);
+}
+function getPaginationOffset(options) {
+  const page = Math.max(1, options.page ?? 1);
+  const maxLimit = options.maxLimit ?? 100;
+  const limit = Math.min(Math.max(1, options.limit ?? 20), maxLimit);
+  const offset = (page - 1) * limit;
+  return { offset, limit };
+}
+function createPaginatedResult(data, total, options) {
+  const { offset, limit } = getPaginationOffset(options);
+  const page = Math.floor(offset / limit) + 1;
+  const totalPages = Math.ceil(total / limit);
+  return {
+    data,
+    pagination: {
+      page,
+      limit,
+      total,
+      totalPages,
+      hasMore: page < totalPages
+    }
+  };
+}
+function escapeLike(value) {
+  return value.replace(/[%_\\]/g, "\\$&");
+}
+function buildSearchPattern(value, mode = "contains") {
+  const escaped = escapeLike(value);
+  switch (mode) {
+    case "startsWith":
+      return `${escaped}%`;
+    case "endsWith":
+      return `%${escaped}`;
+    case "contains":
+    default:
+      return `%${escaped}%`;
+  }
+}
+
+// src/index.ts
+init_types();
+export * from "drizzle-orm";
+async function createDatabase(config) {
+  switch (config.type) {
+    case "postgres": {
+      const { createPostgresAdapter: createPostgresAdapter2 } = await Promise.resolve().then(() => (init_postgres(), postgres_exports));
+      return createPostgresAdapter2(config);
+    }
+    case "neon": {
+      const { createNeonAdapter: createNeonAdapter2 } = await Promise.resolve().then(() => (init_neon(), neon_exports));
+      return createNeonAdapter2(config);
+    }
+    case "d1": {
+      const { createD1Adapter: createD1Adapter2 } = await Promise.resolve().then(() => (init_d1(), d1_exports));
+      return createD1Adapter2(config);
+    }
+    default:
+      throw new DatabaseError(
+        `Unknown database type: ${config.type}`,
+        DatabaseErrorCodes.INVALID_CONFIG
+      );
+  }
+}
+async function createDatabaseFromUrl(connectionString, options) {
+  const url = new URL(connectionString);
+  switch (url.protocol) {
+    case "postgresql:":
+    case "postgres:": {
+      if (url.hostname.includes("neon.tech")) {
+        const { createNeonFromUrl: createNeonFromUrl2 } = await Promise.resolve().then(() => (init_neon(), neon_exports));
+        return createNeonFromUrl2(connectionString, options);
+      }
+      const { createPostgresFromUrl: createPostgresFromUrl2 } = await Promise.resolve().then(() => (init_postgres(), postgres_exports));
+      return createPostgresFromUrl2(connectionString, options);
+    }
+    default:
+      throw new DatabaseError(
+        `Unsupported database URL scheme: ${url.protocol}`,
+        DatabaseErrorCodes.INVALID_CONFIG
+      );
+  }
+}
+export {
+  D1Adapter,
+  DatabaseError,
+  DatabaseErrorCodes,
+  NeonAdapter,
+  PostgresAdapter,
+  buildConnectionString,
+  buildSearchPattern,
+  camelToSnake,
+  createD1Adapter,
+  createDatabase,
+  createDatabaseFromUrl,
+  createNeonAdapter,
+  createNeonFromUrl,
+  createPaginatedResult,
+  createPostgresAdapter,
+  createPostgresFromUrl,
+  escapeLike,
+  generateShortId,
+  generateUUID,
+  getPaginationOffset,
+  isRetryableError,
+  parseConnectionString,
+  retry,
+  sleep,
+  snakeToCamel,
+  transformToCamelCase,
+  transformToSnakeCase
+};
+//# sourceMappingURL=index.js.map