@shogo-ai/db 1.4.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shogo Technologies, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,24 @@
+<!-- SPDX-License-Identifier: MIT -->
+<!-- Copyright (C) 2026 Shogo Technologies, Inc. -->
+
+# @shogo-ai/db
+
+Prisma adapter helpers — auto-detects PostgreSQL/SQLite/libSQL from
+`DATABASE_URL` and wires up the right driver. The actual Prisma client
+generation stays your project's concern; this package just gives you a
+one-line `createPrismaClient(PrismaClient)` factory.
+
+## Install
+
+```bash
+bun add @shogo-ai/db @prisma/client
+# Plus the adapter you actually use:
+bun add @prisma/adapter-pg          # for postgres://...
+bun add @prisma/adapter-libsql      # for file://... or libsql://...
+```
+
+Adapters are optional peers — install only the ones you need.
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

package/dist/index.cjs

@@ -0,0 +1,314 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createAdapterSync: () => createAdapterSync,
+  createDatabaseAdapter: () => createDatabaseAdapter,
+  createPrismaClient: () => createPrismaClient,
+  createPrismaClientSync: () => createPrismaClientSync,
+  detectProvider: () => detectProvider,
+  detectSchemaProvider: () => detectSchemaProvider,
+  getCurrentProvider: () => getCurrentProvider,
+  getTestDatabaseUrl: () => getTestDatabaseUrl,
+  isPostgres: () => isPostgres,
+  isTestMode: () => isTestMode,
+  restoreSchema: () => restoreSchema,
+  transformSchema: () => transformSchema,
+  transformSchemaFile: () => transformSchemaFile
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/adapters.ts
+function detectProvider(url) {
+  const envProvider = process.env.DATABASE_PROVIDER?.toLowerCase();
+  if (envProvider === "sqlite") return "sqlite";
+  if (envProvider === "postgresql" || envProvider === "postgres") return "postgresql";
+  const connectionUrl = url ?? process.env.DATABASE_URL ?? "";
+  if (connectionUrl.startsWith("file:") || connectionUrl.endsWith(".db")) {
+    return "sqlite";
+  }
+  if (connectionUrl.startsWith("postgres://") || connectionUrl.startsWith("postgresql://")) {
+    return "postgresql";
+  }
+  return "postgresql";
+}
+async function createDatabaseAdapter(config = "auto") {
+  const options = typeof config === "string" ? { provider: config } : config;
+  const url = options.url ?? process.env.DATABASE_URL ?? "";
+  const provider = options.provider === "auto" || !options.provider ? detectProvider(url) : options.provider;
+  console.log(`[shogo/db] Creating ${provider} adapter`);
+  if (provider === "sqlite") {
+    return createSqliteAdapter(url || "file:./dev.db");
+  } else {
+    return createPostgresAdapter(url);
+  }
+}
+async function createPostgresAdapter(connectionString) {
+  try {
+    const module2 = await import("@prisma/adapter-pg");
+    const PrismaPg = module2.PrismaPg || module2.default?.PrismaPg;
+    return new PrismaPg({ connectionString });
+  } catch (error) {
+    throw new Error(
+      "Failed to create PostgreSQL adapter. Make sure @prisma/adapter-pg is installed.\nRun: bun add @prisma/adapter-pg"
+    );
+  }
+}
+async function createSqliteAdapter(url) {
+  try {
+    const module2 = await import("@prisma/adapter-libsql");
+    const PrismaLibSql = module2.PrismaLibSql || module2.default?.PrismaLibSql;
+    return new PrismaLibSql({ url });
+  } catch (error) {
+    throw new Error(
+      "Failed to create SQLite adapter. Make sure @prisma/adapter-libsql is installed.\nRun: bun add @prisma/adapter-libsql"
+    );
+  }
+}
+var globalForPrisma = globalThis;
+async function createPrismaClient(PrismaClientClass, config = {}) {
+  if (globalForPrisma.__shogo_prisma) {
+    return globalForPrisma.__shogo_prisma;
+  }
+  const adapter = await createDatabaseAdapter(config);
+  const log = config.log ?? (process.env.NODE_ENV === "development" ? ["warn", "error"] : ["error"]);
+  const client = new PrismaClientClass({
+    adapter,
+    log
+  });
+  if (process.env.NODE_ENV !== "production") {
+    globalForPrisma.__shogo_prisma = client;
+  }
+  return client;
+}
+function createAdapterSync(config = {}) {
+  const url = config.url ?? process.env.DATABASE_URL ?? "";
+  const provider = config.provider === "auto" || !config.provider ? detectProvider(url) : config.provider;
+  console.log(`[shogo/db] Creating ${provider} adapter (sync)`);
+  if (provider === "sqlite") {
+    try {
+      const module2 = require("@prisma/adapter-libsql");
+      const PrismaLibSql = module2.PrismaLibSql || module2.default?.PrismaLibSql;
+      return new PrismaLibSql({ url: url || "file:./dev.db" });
+    } catch {
+      throw new Error(
+        "SQLite adapter not found. Install it with: bun add @prisma/adapter-libsql"
+      );
+    }
+  } else {
+    try {
+      const module2 = require("@prisma/adapter-pg");
+      const PrismaPg = module2.PrismaPg || module2.default?.PrismaPg;
+      return new PrismaPg({ connectionString: url });
+    } catch {
+      throw new Error(
+        "PostgreSQL adapter not found. Install it with: bun add @prisma/adapter-pg"
+      );
+    }
+  }
+}
+function createPrismaClientSync(PrismaClientClass, config = {}) {
+  if (globalForPrisma.__shogo_prisma) {
+    return globalForPrisma.__shogo_prisma;
+  }
+  const adapter = createAdapterSync(config);
+  const log = config.log ?? (process.env.NODE_ENV === "development" ? ["warn", "error"] : ["error"]);
+  const client = new PrismaClientClass({
+    adapter,
+    log
+  });
+  if (process.env.NODE_ENV !== "production") {
+    globalForPrisma.__shogo_prisma = client;
+  }
+  return client;
+}
+function isTestMode() {
+  return detectProvider() === "sqlite";
+}
+function isPostgres() {
+  return detectProvider() === "postgresql";
+}
+function getTestDatabaseUrl() {
+  return "file:./test.db";
+}
+function getCurrentProvider() {
+  return detectProvider();
+}
+
+// src/schema-transformer.ts
+var import_fs = require("fs");
+var import_child_process = require("child_process");
+var import_path = require("path");
+var POSTGRES_TO_SQLITE_TRANSFORMS = [
+  // uuid() is PostgreSQL-specific, use cuid() for compatibility
+  { pattern: /@default\(uuid\(\)\)/g, replacement: "@default(cuid())" },
+  // dbgenerated() with PostgreSQL-specific functions
+  { pattern: /@default\(dbgenerated\("gen_random_uuid\(\)"\)\)/g, replacement: "@default(cuid())" },
+  // auto() is PostgreSQL-specific for autoincrement
+  { pattern: /@default\(auto\(\)\)/g, replacement: "@default(autoincrement())" },
+  // Remove @db.* native type annotations (SQLite doesn't support these)
+  { pattern: /@db\.\w+(\([^)]*\))?/g, replacement: "" }
+];
+var SQLITE_TO_POSTGRES_TRANSFORMS = [
+  // autoincrement() is SQLite-specific, use auto() for PostgreSQL
+  { pattern: /@default\(autoincrement\(\)\)/g, replacement: "@default(auto())" }
+];
+function detectSchemaProvider(schemaContent) {
+  if (schemaContent.includes('provider = "postgresql"') || schemaContent.includes("provider = 'postgresql'")) {
+    return "postgresql";
+  }
+  if (schemaContent.includes('provider = "sqlite"') || schemaContent.includes("provider = 'sqlite'")) {
+    return "sqlite";
+  }
+  return null;
+}
+function transformSchema(schemaContent, targetProvider) {
+  const currentProvider = detectSchemaProvider(schemaContent);
+  const warnings = [];
+  if (currentProvider === targetProvider) {
+    return { content: schemaContent, warnings: [] };
+  }
+  let result = schemaContent;
+  if (targetProvider === "sqlite") {
+    result = result.replace(/provider\s*=\s*"postgresql"/g, 'provider = "sqlite"');
+  } else {
+    result = result.replace(/provider\s*=\s*"sqlite"/g, 'provider = "postgresql"');
+  }
+  const transforms = targetProvider === "sqlite" ? POSTGRES_TO_SQLITE_TRANSFORMS : SQLITE_TO_POSTGRES_TRANSFORMS;
+  for (const { pattern, replacement } of transforms) {
+    const matches = result.match(pattern);
+    if (matches && matches.length > 0) {
+      if (pattern.source.includes("db\\.")) {
+        warnings.push(`Removed PostgreSQL-specific @db.* annotations for SQLite`);
+      }
+      result = result.replace(pattern, replacement);
+    }
+  }
+  result = result.replace(/  +/g, " ");
+  return { content: result, warnings };
+}
+async function transformSchemaFile(options) {
+  const {
+    schemaPath,
+    targetProvider,
+    generate = true,
+    push = false,
+    databaseUrl,
+    verbose = false
+  } = options;
+  const absolutePath = (0, import_path.resolve)(process.cwd(), schemaPath);
+  if (!(0, import_fs.existsSync)(absolutePath)) {
+    throw new Error(`Schema file not found: ${absolutePath}`);
+  }
+  const originalContent = (0, import_fs.readFileSync)(absolutePath, "utf-8");
+  const originalProvider = detectSchemaProvider(originalContent);
+  if (!originalProvider) {
+    throw new Error("Could not detect database provider in schema");
+  }
+  const { content: newContent, warnings } = transformSchema(originalContent, targetProvider);
+  const modified = newContent !== originalContent;
+  if (modified) {
+    (0, import_fs.writeFileSync)(absolutePath, newContent, "utf-8");
+    if (verbose) {
+      console.log(`Transformed schema from ${originalProvider} to ${targetProvider}`);
+    }
+  } else if (verbose) {
+    console.log(`Schema already using ${targetProvider} provider`);
+  }
+  const env = { ...process.env };
+  if (targetProvider === "sqlite") {
+    env.DATABASE_URL = databaseUrl || "file:./test.db";
+  } else if (databaseUrl) {
+    env.DATABASE_URL = databaseUrl;
+  }
+  const schemaDir = (0, import_path.dirname)(absolutePath);
+  if (generate) {
+    if (verbose) {
+      console.log("Running prisma generate...");
+    }
+    try {
+      (0, import_child_process.execSync)("bun x prisma generate", {
+        cwd: schemaDir,
+        env,
+        stdio: verbose ? "inherit" : "pipe"
+      });
+    } catch (error) {
+      throw new Error(`prisma generate failed: ${error}`);
+    }
+  }
+  if (push) {
+    if (verbose) {
+      console.log("Running prisma db push...");
+    }
+    try {
+      (0, import_child_process.execSync)("bun x prisma db push", {
+        cwd: schemaDir,
+        env,
+        stdio: verbose ? "inherit" : "pipe"
+      });
+    } catch (error) {
+      throw new Error(`prisma db push failed: ${error}`);
+    }
+  }
+  return {
+    modified,
+    originalProvider,
+    newProvider: targetProvider,
+    schemaPath: absolutePath,
+    warnings
+  };
+}
+async function restoreSchema(schemaPath, verbose = false) {
+  await transformSchemaFile({
+    schemaPath,
+    targetProvider: "postgresql",
+    generate: true,
+    push: false,
+    verbose
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAdapterSync,
+  createDatabaseAdapter,
+  createPrismaClient,
+  createPrismaClientSync,
+  detectProvider,
+  detectSchemaProvider,
+  getCurrentProvider,
+  getTestDatabaseUrl,
+  isPostgres,
+  isTestMode,
+  restoreSchema,
+  transformSchema,
+  transformSchemaFile
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.d.cts

@@ -0,0 +1,172 @@
+/**
+ * Shogo Database Adapters
+ *
+ * Provides flexible database adapter support for Prisma.
+ * Allows easy switching between PostgreSQL (production) and SQLite (testing/development).
+ *
+ * The adapter auto-detects the database type from DATABASE_URL or DATABASE_PROVIDER,
+ * making it easy to run the same code against different databases.
+ *
+ * @example
+ * ```typescript
+ * // In your src/lib/db.ts
+ * import { createPrismaClient } from '@shogo-ai/sdk/db'
+ * import { PrismaClient } from '../generated/prisma/client'
+ *
+ * // Auto-detects PostgreSQL vs SQLite based on DATABASE_URL
+ * export const prisma = await createPrismaClient(PrismaClient)
+ *
+ * // For testing with SQLite:
+ * // DATABASE_URL=file:./test.db bun test
+ * ```
+ */
+type DatabaseProvider$1 = 'postgresql' | 'sqlite' | 'auto';
+interface DatabaseAdapterConfig {
+    /**
+     * Database provider to use
+     * - 'postgresql': Use PostgreSQL adapter (requires @prisma/adapter-pg)
+     * - 'sqlite': Use SQLite adapter (requires @prisma/adapter-libsql)
+     * - 'auto': Auto-detect based on DATABASE_PROVIDER env var or DATABASE_URL format
+     */
+    provider?: DatabaseProvider$1;
+    /**
+     * Connection string (defaults to DATABASE_URL env var)
+     */
+    url?: string;
+    /**
+     * Prisma log levels
+     */
+    log?: ('query' | 'info' | 'warn' | 'error')[];
+}
+/**
+ * Detect database provider from connection string
+ */
+declare function detectProvider(url?: string): 'postgresql' | 'sqlite';
+/**
+ * Create a database adapter based on configuration
+ *
+ * @param config - Configuration options or provider string
+ * @returns Promise resolving to the appropriate Prisma adapter
+ */
+declare function createDatabaseAdapter(config?: DatabaseAdapterConfig | DatabaseProvider$1): Promise<any>;
+/**
+ * Create a Prisma client with auto-detected adapter (async)
+ *
+ * This is the main entry point for database access. It:
+ * 1. Auto-detects PostgreSQL vs SQLite from DATABASE_URL
+ * 2. Creates the appropriate adapter
+ * 3. Caches the client globally to prevent connection exhaustion
+ *
+ * @example
+ * ```typescript
+ * import { createPrismaClient } from '@shogo-ai/sdk/db'
+ * import { PrismaClient } from '../generated/prisma/client'
+ *
+ * export const prisma = await createPrismaClient(PrismaClient)
+ * ```
+ */
+declare function createPrismaClient<T>(PrismaClientClass: new (options: any) => T, config?: DatabaseAdapterConfig): Promise<T>;
+/**
+ * Create a database adapter synchronously (uses require)
+ *
+ * This is useful when you need synchronous initialization.
+ * Falls back gracefully if the adapter package is not installed.
+ *
+ * @example
+ * ```typescript
+ * import { createAdapterSync } from '@shogo-ai/sdk/db'
+ * import { PrismaClient } from '../generated/prisma/client'
+ *
+ * const adapter = createAdapterSync()
+ * export const prisma = new PrismaClient({ adapter })
+ * ```
+ */
+declare function createAdapterSync(config?: DatabaseAdapterConfig): any;
+/**
+ * Create a Prisma client synchronously with auto-detected adapter
+ *
+ * @example
+ * ```typescript
+ * import { createPrismaClientSync } from '@shogo-ai/sdk/db'
+ * import { PrismaClient } from '../generated/prisma/client'
+ *
+ * export const prisma = createPrismaClientSync(PrismaClient)
+ * ```
+ */
+declare function createPrismaClientSync<T>(PrismaClientClass: new (options: any) => T, config?: DatabaseAdapterConfig): T;
+/**
+ * Check if running in test/SQLite mode
+ */
+declare function isTestMode(): boolean;
+/**
+ * Check if running with PostgreSQL
+ */
+declare function isPostgres(): boolean;
+/**
+ * Get recommended DATABASE_URL for testing with SQLite
+ */
+declare function getTestDatabaseUrl(): string;
+/**
+ * Get the current database provider
+ */
+declare function getCurrentProvider(): DatabaseProvider$1;
+
+/**
+ * Prisma Schema Transformer
+ *
+ * Transforms Prisma schemas between PostgreSQL and SQLite providers,
+ * handling dialect-specific differences.
+ *
+ * This enables a workflow where:
+ * - Production uses PostgreSQL
+ * - Tests can run with SQLite (fast, no infrastructure)
+ * - Tests can also run with PostgreSQL (for integration testing)
+ */
+type DatabaseProvider = 'postgresql' | 'sqlite';
+interface TransformOptions {
+    /** Path to the Prisma schema file */
+    schemaPath: string;
+    /** Target database provider */
+    targetProvider: DatabaseProvider;
+    /** Run prisma generate after transformation */
+    generate?: boolean;
+    /** Run prisma db push after transformation (useful for SQLite) */
+    push?: boolean;
+    /** DATABASE_URL to use (defaults to file:./test.db for SQLite) */
+    databaseUrl?: string;
+    /** Print verbose output */
+    verbose?: boolean;
+}
+interface TransformResult {
+    /** Whether the schema was modified */
+    modified: boolean;
+    /** The original provider */
+    originalProvider: DatabaseProvider;
+    /** The new provider */
+    newProvider: DatabaseProvider;
+    /** Path to the schema file */
+    schemaPath: string;
+    /** Any warnings generated during transformation */
+    warnings: string[];
+}
+/**
+ * Detect the current provider in a schema
+ */
+declare function detectSchemaProvider(schemaContent: string): DatabaseProvider | null;
+/**
+ * Transform a Prisma schema from one provider to another
+ */
+declare function transformSchema(schemaContent: string, targetProvider: DatabaseProvider): {
+    content: string;
+    warnings: string[];
+};
+/**
+ * Transform schema and optionally run Prisma commands
+ */
+declare function transformSchemaFile(options: TransformOptions): Promise<TransformResult>;
+/**
+ * Restore schema to PostgreSQL (the canonical provider)
+ */
+declare function restoreSchema(schemaPath: string, verbose?: boolean): Promise<void>;
+
+export { type DatabaseAdapterConfig, type DatabaseProvider$1 as DatabaseProvider, type TransformOptions, type TransformResult, createAdapterSync, createDatabaseAdapter, createPrismaClient, createPrismaClientSync, detectProvider, detectSchemaProvider, getCurrentProvider, getTestDatabaseUrl, isPostgres, isTestMode, restoreSchema, transformSchema, transformSchemaFile };

package/dist/index.d.ts

@@ -0,0 +1,172 @@
+/**
+ * Shogo Database Adapters
+ *
+ * Provides flexible database adapter support for Prisma.
+ * Allows easy switching between PostgreSQL (production) and SQLite (testing/development).
+ *
+ * The adapter auto-detects the database type from DATABASE_URL or DATABASE_PROVIDER,
+ * making it easy to run the same code against different databases.
+ *
+ * @example
+ * ```typescript
+ * // In your src/lib/db.ts
+ * import { createPrismaClient } from '@shogo-ai/sdk/db'
+ * import { PrismaClient } from '../generated/prisma/client'
+ *
+ * // Auto-detects PostgreSQL vs SQLite based on DATABASE_URL
+ * export const prisma = await createPrismaClient(PrismaClient)
+ *
+ * // For testing with SQLite:
+ * // DATABASE_URL=file:./test.db bun test
+ * ```
+ */
+type DatabaseProvider$1 = 'postgresql' | 'sqlite' | 'auto';
+interface DatabaseAdapterConfig {
+    /**
+     * Database provider to use
+     * - 'postgresql': Use PostgreSQL adapter (requires @prisma/adapter-pg)
+     * - 'sqlite': Use SQLite adapter (requires @prisma/adapter-libsql)
+     * - 'auto': Auto-detect based on DATABASE_PROVIDER env var or DATABASE_URL format
+     */
+    provider?: DatabaseProvider$1;
+    /**
+     * Connection string (defaults to DATABASE_URL env var)
+     */
+    url?: string;
+    /**
+     * Prisma log levels
+     */
+    log?: ('query' | 'info' | 'warn' | 'error')[];
+}
+/**
+ * Detect database provider from connection string
+ */
+declare function detectProvider(url?: string): 'postgresql' | 'sqlite';
+/**
+ * Create a database adapter based on configuration
+ *
+ * @param config - Configuration options or provider string
+ * @returns Promise resolving to the appropriate Prisma adapter
+ */
+declare function createDatabaseAdapter(config?: DatabaseAdapterConfig | DatabaseProvider$1): Promise<any>;
+/**
+ * Create a Prisma client with auto-detected adapter (async)
+ *
+ * This is the main entry point for database access. It:
+ * 1. Auto-detects PostgreSQL vs SQLite from DATABASE_URL
+ * 2. Creates the appropriate adapter
+ * 3. Caches the client globally to prevent connection exhaustion
+ *
+ * @example
+ * ```typescript
+ * import { createPrismaClient } from '@shogo-ai/sdk/db'
+ * import { PrismaClient } from '../generated/prisma/client'
+ *
+ * export const prisma = await createPrismaClient(PrismaClient)
+ * ```
+ */
+declare function createPrismaClient<T>(PrismaClientClass: new (options: any) => T, config?: DatabaseAdapterConfig): Promise<T>;
+/**
+ * Create a database adapter synchronously (uses require)
+ *
+ * This is useful when you need synchronous initialization.
+ * Falls back gracefully if the adapter package is not installed.
+ *
+ * @example
+ * ```typescript
+ * import { createAdapterSync } from '@shogo-ai/sdk/db'
+ * import { PrismaClient } from '../generated/prisma/client'
+ *
+ * const adapter = createAdapterSync()
+ * export const prisma = new PrismaClient({ adapter })
+ * ```
+ */
+declare function createAdapterSync(config?: DatabaseAdapterConfig): any;
+/**
+ * Create a Prisma client synchronously with auto-detected adapter
+ *
+ * @example
+ * ```typescript
+ * import { createPrismaClientSync } from '@shogo-ai/sdk/db'
+ * import { PrismaClient } from '../generated/prisma/client'
+ *
+ * export const prisma = createPrismaClientSync(PrismaClient)
+ * ```
+ */
+declare function createPrismaClientSync<T>(PrismaClientClass: new (options: any) => T, config?: DatabaseAdapterConfig): T;
+/**
+ * Check if running in test/SQLite mode
+ */
+declare function isTestMode(): boolean;
+/**
+ * Check if running with PostgreSQL
+ */
+declare function isPostgres(): boolean;
+/**
+ * Get recommended DATABASE_URL for testing with SQLite
+ */
+declare function getTestDatabaseUrl(): string;
+/**
+ * Get the current database provider
+ */
+declare function getCurrentProvider(): DatabaseProvider$1;
+
+/**
+ * Prisma Schema Transformer
+ *
+ * Transforms Prisma schemas between PostgreSQL and SQLite providers,
+ * handling dialect-specific differences.
+ *
+ * This enables a workflow where:
+ * - Production uses PostgreSQL
+ * - Tests can run with SQLite (fast, no infrastructure)
+ * - Tests can also run with PostgreSQL (for integration testing)
+ */
+type DatabaseProvider = 'postgresql' | 'sqlite';
+interface TransformOptions {
+    /** Path to the Prisma schema file */
+    schemaPath: string;
+    /** Target database provider */
+    targetProvider: DatabaseProvider;
+    /** Run prisma generate after transformation */
+    generate?: boolean;
+    /** Run prisma db push after transformation (useful for SQLite) */
+    push?: boolean;
+    /** DATABASE_URL to use (defaults to file:./test.db for SQLite) */
+    databaseUrl?: string;
+    /** Print verbose output */
+    verbose?: boolean;
+}
+interface TransformResult {
+    /** Whether the schema was modified */
+    modified: boolean;
+    /** The original provider */
+    originalProvider: DatabaseProvider;
+    /** The new provider */
+    newProvider: DatabaseProvider;
+    /** Path to the schema file */
+    schemaPath: string;
+    /** Any warnings generated during transformation */
+    warnings: string[];
+}
+/**
+ * Detect the current provider in a schema
+ */
+declare function detectSchemaProvider(schemaContent: string): DatabaseProvider | null;
+/**
+ * Transform a Prisma schema from one provider to another
+ */
+declare function transformSchema(schemaContent: string, targetProvider: DatabaseProvider): {
+    content: string;
+    warnings: string[];
+};
+/**
+ * Transform schema and optionally run Prisma commands
+ */
+declare function transformSchemaFile(options: TransformOptions): Promise<TransformResult>;
+/**
+ * Restore schema to PostgreSQL (the canonical provider)
+ */
+declare function restoreSchema(schemaPath: string, verbose?: boolean): Promise<void>;
+
+export { type DatabaseAdapterConfig, type DatabaseProvider$1 as DatabaseProvider, type TransformOptions, type TransformResult, createAdapterSync, createDatabaseAdapter, createPrismaClient, createPrismaClientSync, detectProvider, detectSchemaProvider, getCurrentProvider, getTestDatabaseUrl, isPostgres, isTestMode, restoreSchema, transformSchema, transformSchemaFile };

package/dist/index.js

@@ -0,0 +1,272 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/adapters.ts
+function detectProvider(url) {
+  const envProvider = process.env.DATABASE_PROVIDER?.toLowerCase();
+  if (envProvider === "sqlite") return "sqlite";
+  if (envProvider === "postgresql" || envProvider === "postgres") return "postgresql";
+  const connectionUrl = url ?? process.env.DATABASE_URL ?? "";
+  if (connectionUrl.startsWith("file:") || connectionUrl.endsWith(".db")) {
+    return "sqlite";
+  }
+  if (connectionUrl.startsWith("postgres://") || connectionUrl.startsWith("postgresql://")) {
+    return "postgresql";
+  }
+  return "postgresql";
+}
+async function createDatabaseAdapter(config = "auto") {
+  const options = typeof config === "string" ? { provider: config } : config;
+  const url = options.url ?? process.env.DATABASE_URL ?? "";
+  const provider = options.provider === "auto" || !options.provider ? detectProvider(url) : options.provider;
+  console.log(`[shogo/db] Creating ${provider} adapter`);
+  if (provider === "sqlite") {
+    return createSqliteAdapter(url || "file:./dev.db");
+  } else {
+    return createPostgresAdapter(url);
+  }
+}
+async function createPostgresAdapter(connectionString) {
+  try {
+    const module = await import("@prisma/adapter-pg");
+    const PrismaPg = module.PrismaPg || module.default?.PrismaPg;
+    return new PrismaPg({ connectionString });
+  } catch (error) {
+    throw new Error(
+      "Failed to create PostgreSQL adapter. Make sure @prisma/adapter-pg is installed.\nRun: bun add @prisma/adapter-pg"
+    );
+  }
+}
+async function createSqliteAdapter(url) {
+  try {
+    const module = await import("@prisma/adapter-libsql");
+    const PrismaLibSql = module.PrismaLibSql || module.default?.PrismaLibSql;
+    return new PrismaLibSql({ url });
+  } catch (error) {
+    throw new Error(
+      "Failed to create SQLite adapter. Make sure @prisma/adapter-libsql is installed.\nRun: bun add @prisma/adapter-libsql"
+    );
+  }
+}
+var globalForPrisma = globalThis;
+async function createPrismaClient(PrismaClientClass, config = {}) {
+  if (globalForPrisma.__shogo_prisma) {
+    return globalForPrisma.__shogo_prisma;
+  }
+  const adapter = await createDatabaseAdapter(config);
+  const log = config.log ?? (process.env.NODE_ENV === "development" ? ["warn", "error"] : ["error"]);
+  const client = new PrismaClientClass({
+    adapter,
+    log
+  });
+  if (process.env.NODE_ENV !== "production") {
+    globalForPrisma.__shogo_prisma = client;
+  }
+  return client;
+}
+function createAdapterSync(config = {}) {
+  const url = config.url ?? process.env.DATABASE_URL ?? "";
+  const provider = config.provider === "auto" || !config.provider ? detectProvider(url) : config.provider;
+  console.log(`[shogo/db] Creating ${provider} adapter (sync)`);
+  if (provider === "sqlite") {
+    try {
+      const module = __require("@prisma/adapter-libsql");
+      const PrismaLibSql = module.PrismaLibSql || module.default?.PrismaLibSql;
+      return new PrismaLibSql({ url: url || "file:./dev.db" });
+    } catch {
+      throw new Error(
+        "SQLite adapter not found. Install it with: bun add @prisma/adapter-libsql"
+      );
+    }
+  } else {
+    try {
+      const module = __require("@prisma/adapter-pg");
+      const PrismaPg = module.PrismaPg || module.default?.PrismaPg;
+      return new PrismaPg({ connectionString: url });
+    } catch {
+      throw new Error(
+        "PostgreSQL adapter not found. Install it with: bun add @prisma/adapter-pg"
+      );
+    }
+  }
+}
+function createPrismaClientSync(PrismaClientClass, config = {}) {
+  if (globalForPrisma.__shogo_prisma) {
+    return globalForPrisma.__shogo_prisma;
+  }
+  const adapter = createAdapterSync(config);
+  const log = config.log ?? (process.env.NODE_ENV === "development" ? ["warn", "error"] : ["error"]);
+  const client = new PrismaClientClass({
+    adapter,
+    log
+  });
+  if (process.env.NODE_ENV !== "production") {
+    globalForPrisma.__shogo_prisma = client;
+  }
+  return client;
+}
+function isTestMode() {
+  return detectProvider() === "sqlite";
+}
+function isPostgres() {
+  return detectProvider() === "postgresql";
+}
+function getTestDatabaseUrl() {
+  return "file:./test.db";
+}
+function getCurrentProvider() {
+  return detectProvider();
+}
+
+// src/schema-transformer.ts
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { execSync } from "child_process";
+import { resolve, dirname } from "path";
+var POSTGRES_TO_SQLITE_TRANSFORMS = [
+  // uuid() is PostgreSQL-specific, use cuid() for compatibility
+  { pattern: /@default\(uuid\(\)\)/g, replacement: "@default(cuid())" },
+  // dbgenerated() with PostgreSQL-specific functions
+  { pattern: /@default\(dbgenerated\("gen_random_uuid\(\)"\)\)/g, replacement: "@default(cuid())" },
+  // auto() is PostgreSQL-specific for autoincrement
+  { pattern: /@default\(auto\(\)\)/g, replacement: "@default(autoincrement())" },
+  // Remove @db.* native type annotations (SQLite doesn't support these)
+  { pattern: /@db\.\w+(\([^)]*\))?/g, replacement: "" }
+];
+var SQLITE_TO_POSTGRES_TRANSFORMS = [
+  // autoincrement() is SQLite-specific, use auto() for PostgreSQL
+  { pattern: /@default\(autoincrement\(\)\)/g, replacement: "@default(auto())" }
+];
+function detectSchemaProvider(schemaContent) {
+  if (schemaContent.includes('provider = "postgresql"') || schemaContent.includes("provider = 'postgresql'")) {
+    return "postgresql";
+  }
+  if (schemaContent.includes('provider = "sqlite"') || schemaContent.includes("provider = 'sqlite'")) {
+    return "sqlite";
+  }
+  return null;
+}
+function transformSchema(schemaContent, targetProvider) {
+  const currentProvider = detectSchemaProvider(schemaContent);
+  const warnings = [];
+  if (currentProvider === targetProvider) {
+    return { content: schemaContent, warnings: [] };
+  }
+  let result = schemaContent;
+  if (targetProvider === "sqlite") {
+    result = result.replace(/provider\s*=\s*"postgresql"/g, 'provider = "sqlite"');
+  } else {
+    result = result.replace(/provider\s*=\s*"sqlite"/g, 'provider = "postgresql"');
+  }
+  const transforms = targetProvider === "sqlite" ? POSTGRES_TO_SQLITE_TRANSFORMS : SQLITE_TO_POSTGRES_TRANSFORMS;
+  for (const { pattern, replacement } of transforms) {
+    const matches = result.match(pattern);
+    if (matches && matches.length > 0) {
+      if (pattern.source.includes("db\\.")) {
+        warnings.push(`Removed PostgreSQL-specific @db.* annotations for SQLite`);
+      }
+      result = result.replace(pattern, replacement);
+    }
+  }
+  result = result.replace(/  +/g, " ");
+  return { content: result, warnings };
+}
+async function transformSchemaFile(options) {
+  const {
+    schemaPath,
+    targetProvider,
+    generate = true,
+    push = false,
+    databaseUrl,
+    verbose = false
+  } = options;
+  const absolutePath = resolve(process.cwd(), schemaPath);
+  if (!existsSync(absolutePath)) {
+    throw new Error(`Schema file not found: ${absolutePath}`);
+  }
+  const originalContent = readFileSync(absolutePath, "utf-8");
+  const originalProvider = detectSchemaProvider(originalContent);
+  if (!originalProvider) {
+    throw new Error("Could not detect database provider in schema");
+  }
+  const { content: newContent, warnings } = transformSchema(originalContent, targetProvider);
+  const modified = newContent !== originalContent;
+  if (modified) {
+    writeFileSync(absolutePath, newContent, "utf-8");
+    if (verbose) {
+      console.log(`Transformed schema from ${originalProvider} to ${targetProvider}`);
+    }
+  } else if (verbose) {
+    console.log(`Schema already using ${targetProvider} provider`);
+  }
+  const env = { ...process.env };
+  if (targetProvider === "sqlite") {
+    env.DATABASE_URL = databaseUrl || "file:./test.db";
+  } else if (databaseUrl) {
+    env.DATABASE_URL = databaseUrl;
+  }
+  const schemaDir = dirname(absolutePath);
+  if (generate) {
+    if (verbose) {
+      console.log("Running prisma generate...");
+    }
+    try {
+      execSync("bun x prisma generate", {
+        cwd: schemaDir,
+        env,
+        stdio: verbose ? "inherit" : "pipe"
+      });
+    } catch (error) {
+      throw new Error(`prisma generate failed: ${error}`);
+    }
+  }
+  if (push) {
+    if (verbose) {
+      console.log("Running prisma db push...");
+    }
+    try {
+      execSync("bun x prisma db push", {
+        cwd: schemaDir,
+        env,
+        stdio: verbose ? "inherit" : "pipe"
+      });
+    } catch (error) {
+      throw new Error(`prisma db push failed: ${error}`);
+    }
+  }
+  return {
+    modified,
+    originalProvider,
+    newProvider: targetProvider,
+    schemaPath: absolutePath,
+    warnings
+  };
+}
+async function restoreSchema(schemaPath, verbose = false) {
+  await transformSchemaFile({
+    schemaPath,
+    targetProvider: "postgresql",
+    generate: true,
+    push: false,
+    verbose
+  });
+}
+export {
+  createAdapterSync,
+  createDatabaseAdapter,
+  createPrismaClient,
+  createPrismaClientSync,
+  detectProvider,
+  detectSchemaProvider,
+  getCurrentProvider,
+  getTestDatabaseUrl,
+  isPostgres,
+  isTestMode,
+  restoreSchema,
+  transformSchema,
+  transformSchemaFile
+};
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@shogo-ai/db",
+  "version": "1.4.1",
+  "description": "Shogo DB — Prisma adapter helpers for PostgreSQL/SQLite/libSQL with auto-detection from DATABASE_URL.",
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.cjs",
+    "dist/**/*.d.ts",
+    "dist/**/*.d.cts"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "bun --no-env-file test src/"
+  },
+  "peerDependencies": {
+    "@prisma/adapter-pg": "^7.3.0",
+    "@prisma/adapter-libsql": ">=0.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@prisma/adapter-pg": {
+      "optional": true
+    },
+    "@prisma/adapter-libsql": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@prisma/adapter-libsql": "^7.3.0",
+    "@types/node": "^25.5.0",
+    "tsup": "^8.0.0",
+    "typescript": "^6.0.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "shogo",
+    "prisma",
+    "postgres",
+    "sqlite",
+    "libsql"
+  ],
+  "author": "Shogo Labs",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shogo-labs/shogo-ai.git",
+    "directory": "packages/db"
+  },
+  "homepage": "https://github.com/shogo-labs/shogo-ai/tree/main/packages/db#readme",
+  "bugs": {
+    "url": "https://github.com/shogo-labs/shogo-ai/issues"
+  }
+}