@develit-io/backend-sdk 5.6.0 → 5.8.0

package/dist/index.cjs

@@ -7,7 +7,10 @@ require('http-status-codes');
 const z = require('zod/v4/core');
 const h3 = require('h3');
 const consola = require('consola');
-const drizzleKit = require('drizzle-kit');
+const fs = require('fs');
+const crypto$1 = require('node:crypto');
+const path = require('path');
+const jsoncParser = require('jsonc-parser');
 const superjson = require('superjson');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
@@ -25,6 +28,9 @@ function _interopNamespaceCompat(e) {
 }
 
 const z__namespace = /*#__PURE__*/_interopNamespaceCompat(z);
+const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+const crypto__default = /*#__PURE__*/_interopDefaultCompat(crypto$1);
+const path__default = /*#__PURE__*/_interopDefaultCompat(path);
 const superjson__default = /*#__PURE__*/_interopDefaultCompat(superjson);
 
 const base = {
@@ -210,28 +216,116 @@ async function handleAction(worker, input, options = {}, actionExecution) {
   }
 }
 
-const drizzleConfig = drizzleKit.defineConfig({
-  dialect: "sqlite",
-  schema: "./src/database/schema/",
-  out: "./src/database/migrations/"
-});
-function first(rows) {
-  return rows.length > 0 ? rows[0] : void 0;
-}
-function firstOrError(rows) {
-  if (rows.length === 0) {
-    throw new Error("Query did not return any data.");
-  }
-  return rows[0];
+const asNonEmpty = (arr) => {
+  return arr.length > 0 ? [arr[0], ...arr.slice(1)] : null;
+};
+
+function createAuditLogWriter(table) {
+  return (logs, db) => {
+    if (logs.length === 0) return [];
+    const auditRecords = logs.map((log) => ({
+      ...log,
+      createdAt: /* @__PURE__ */ new Date(),
+      id: crypto.randomUUID()
+    }));
+    return [db.insert(table).values(auditRecords)];
+  };
 }
-const uuidv4 = () => crypto.randomUUID();
 
-const calculateExponentialBackoff = (attempts, baseDelaySeconds) => {
-  return baseDelaySeconds ** attempts;
+function durableObjectNamespaceIdFromName(uniqueKey, name) {
+  const key = crypto__default.createHash("sha256").update(uniqueKey).digest();
+  const nameHmac = crypto__default.createHmac("sha256", key).update(name).digest().subarray(0, 16);
+  const hmac = crypto__default.createHmac("sha256", key).update(nameHmac).digest().subarray(0, 16);
+  return Buffer.concat([nameHmac, hmac]).toString("hex");
+}
+const getDatabaseIdFromWrangler = () => {
+  try {
+    const wranglerPath = path__default.resolve("./wrangler.jsonc");
+    const wranglerContent = fs__default.readFileSync(wranglerPath, "utf-8");
+    const errors = [];
+    const config = jsoncParser.parse(wranglerContent, errors, { allowTrailingComma: true });
+    if (errors.length) {
+      throw new Error("Invalid JSONC in wrangler.jsonc");
+    }
+    const environment = process.env.ENVIRONMENT || "localhost";
+    let databaseId;
+    if (environment !== "localhost" && config.env?.[environment]) {
+      databaseId = config.env[environment].d1_databases?.[0]?.database_id;
+      console.log(
+        `Using database_id for environment '${environment}': ${databaseId}`
+      );
+    }
+    if (!databaseId) {
+      databaseId = config.d1_databases?.[0]?.database_id;
+      console.log(
+        `Using default database_id for environment '${environment}': ${databaseId}`
+      );
+    }
+    if (!databaseId) {
+      throw new Error("database_id not found in wrangler.jsonc");
+    }
+    return databaseId;
+  } catch (err) {
+    console.warn(
+      `Warning: Could not read database_id from wrangler.jsonc: ${err}`
+    );
+  }
 };
-
-const asNonEmpty = (arr) => {
-  return arr.length > 0 ? [arr[0], ...arr.slice(1)] : null;
+const isRemoteEnvironment = () => {
+  const environment = process.env.ENVIRONMENT;
+  return environment && environment !== "localhost";
+};
+const getLocalD1 = (databaseId) => {
+  const name = durableObjectNamespaceIdFromName(
+    "miniflare-D1DatabaseObject",
+    databaseId
+  );
+  const searchPaths = [
+    path__default.resolve("../../.wrangler"),
+    // Root of monorepo
+    path__default.resolve("./.wrangler")
+    // Current directory
+  ];
+  for (const basePath of searchPaths) {
+    try {
+      const dbFile = fs__default.readdirSync(basePath, { encoding: "utf-8", recursive: true }).find((f) => f.includes(name));
+      if (dbFile) {
+        const url = path__default.resolve(basePath, dbFile);
+        console.log(`Found D1 database at: ${url}`);
+        return url;
+      } else {
+        throw new Error(`No D1 database file found in ${basePath}`);
+      }
+    } catch {
+      console.warn(`Could not search in ${basePath}`);
+      continue;
+    }
+  }
+};
+const getCredentials = () => {
+  const databaseId = getDatabaseIdFromWrangler() ?? "";
+  if (isRemoteEnvironment()) {
+    return {
+      driver: "d1-http",
+      dbCredentials: {
+        accountId: process.env.CLOUDFLARE_ACCOUNT_ID,
+        databaseId,
+        token: process.env.CLOUDFLARE_API_TOKEN
+      }
+    };
+  } else {
+    return {
+      dbCredentials: {
+        url: getLocalD1(databaseId)
+      }
+    };
+  }
+};
+const drizzleD1Config = {
+  schema: "./src/database/schema/",
+  out: "./src/database/migrations/",
+  dialect: "sqlite",
+  ...getCredentials()
 };
 
 class DatabaseTransaction {
@@ -296,17 +390,33 @@ const defineCommand = (handler) => {
   });
 };
 
-function createAuditLogWriter(table) {
-  return (logs, db) => {
-    if (logs.length === 0) return [];
-    const auditRecords = logs.map((log) => ({
-      ...log,
-      createdAt: /* @__PURE__ */ new Date(),
-      id: crypto.randomUUID()
-    }));
-    return [db.insert(table).values(auditRecords)];
-  };
+function first(rows) {
+  return rows.length > 0 ? rows[0] : void 0;
+}
+function firstOrError(rows) {
+  if (rows.length === 0) {
+    throw new Error("Query did not return any data.");
+  }
+  return rows[0];
 }
+const uuidv4 = () => crypto.randomUUID();
+
+const drizzlePgConfig = {
+  schema: "./src/database/schema/",
+  out: "./src/database/migrations/",
+  dialect: "postgresql",
+  dbCredentials: {
+    url: process.env.DATABASE_URL
+  },
+  migrations: {
+    table: "__drizzle_migrations",
+    schema: "public"
+  }
+};
+
+const calculateExponentialBackoff = (attempts, baseDelaySeconds) => {
+  return baseDelaySeconds ** attempts;
+};
 
 const service = (serviceName) => {
   return function(constructor) {
@@ -455,7 +565,9 @@ exports.createAuditLogWriter = createAuditLogWriter;
 exports.createInternalError = createInternalError;
 exports.defineCommand = defineCommand;
 exports.develitWorker = develitWorker;
-exports.drizzleConfig = drizzleConfig;
+exports.drizzleD1Config = drizzleD1Config;
+exports.drizzlePgConfig = drizzlePgConfig;
+exports.durableObjectNamespaceIdFromName = durableObjectNamespaceIdFromName;
 exports.first = first;
 exports.firstOrError = firstOrError;
 exports.handleAction = handleAction;

package/dist/index.d.cts

@@ -8,7 +8,6 @@ import { StatusCodes, ReasonPhrases } from 'http-status-codes';
 export { ReasonPhrases as InternalResponsePhrase, StatusCodes as InternalResponseStatus } from 'http-status-codes';
 import * as z from 'zod/v4/core';
 import { Queue } from '@cloudflare/workers-types';
-import * as drizzle_kit from 'drizzle-kit';
 import { BatchItem } from 'drizzle-orm/batch';
 import { DrizzleD1Database } from 'drizzle-orm/d1';
 
@@ -162,7 +161,86 @@ type ValidatedInput<T extends z.$ZodType> = z.infer<T>;
  */
 type ActionExecution<TInput, TOutput> = TInput extends null ? () => Promise<TOutput> : (input: TInput) => Promise<TOutput>;
 
-declare const drizzleConfig: drizzle_kit.Config;
+interface AuditLogPayload<T> {
+    action: T;
+    actorId: string;
+    actorUsername?: string;
+    service: string;
+    entityId?: string;
+}
+
+type AuditLogTable = AnySQLiteTable | AnyPgTable;
+type AuditLogWriter<TAuditAction = string> = (logs: AuditLogPayload<TAuditAction>[], db: DrizzleD1Database<Record<string, unknown>>) => BatchItem<'sqlite'>[];
+/**
+ * Creates an audit log writer function that inserts audit logs into a specified table
+ *
+ * @param table - The Drizzle table definition for audit logs
+ * @returns A function that can be passed to DatabaseTransaction constructor
+ *
+ * @example
+ * ```typescript
+ * import { createAuditLogWriter } from '@develit-io/workers-sdk'
+ * import { auditLogsTable } from './schema'
+ *
+ * const auditWriter = createAuditLogWriter(auditLogsTable)
+ *
+ * // Use in initializeDB
+ * this.initializeDB(env.DB, schema, auditWriter)
+ * ```
+ */
+declare function createAuditLogWriter<TAuditAction = string>(table: AuditLogTable): AuditLogWriter<TAuditAction>;
+
+declare function durableObjectNamespaceIdFromName(uniqueKey: string, name: string): string;
+declare const drizzleD1Config: {
+    driver: string;
+    dbCredentials: {
+        accountId: string | undefined;
+        databaseId: string;
+        token: string | undefined;
+        url?: undefined;
+    };
+    schema: string;
+    out: string;
+    dialect: "sqlite";
+} | {
+    dbCredentials: {
+        url: string | undefined;
+        accountId?: undefined;
+        databaseId?: undefined;
+        token?: undefined;
+    };
+    driver?: undefined;
+    schema: string;
+    out: string;
+    dialect: "sqlite";
+};
+
+interface Command<TAuditAction = string> {
+    handler: (db: DrizzleD1Database<Record<string, unknown>>) => CommandItem<TAuditAction>;
+}
+type CommandFactory<TParams = void, TAuditAction = string> = TParams extends void ? () => Command<TAuditAction> : (params: TParams) => Command<TAuditAction>;
+declare const defineCommand: <TParams = void, TAuditAction = string>(handler: (db: DrizzleD1Database<Record<string, unknown>>, params: TParams) => {
+    command: BatchItem<"sqlite">;
+    logPayload: CommandLogPayload<TAuditAction>;
+    id: string;
+}) => CommandFactory<TParams, TAuditAction>;
+
+declare class DatabaseTransaction<TAuditAction = string> {
+    private db;
+    private serviceName?;
+    private auditLogWriter?;
+    private commands;
+    private logs;
+    private ids;
+    constructor(db: DrizzleD1Database<Record<string, unknown>>, serviceName?: string | undefined, auditLogWriter?: ((logs: AuditLogPayload<TAuditAction>[], db: DrizzleD1Database<Record<string, unknown>>) => BatchItem<"sqlite">[]) | undefined);
+    enqueue<U extends Command<TAuditAction>, T extends Readonly<U> | Readonly<[U, ...U[]]>>(commands: T): string | string[] | undefined;
+    execute(commandItem: Command<TAuditAction>): Promise<void>;
+    executeAll(): Promise<void>;
+    getLogs(): readonly AuditLogPayload<TAuditAction>[];
+    getIds(): readonly string[];
+    getCommandsCount(): number;
+}
+
 declare function first<T>(rows: T[]): T | undefined;
 declare function firstOrError<T>(rows: T[]): T;
 declare const uuidv4: () => `${string}-${string}-${string}-${string}-${string}`;
@@ -174,6 +252,21 @@ declare const createInternalError: (error: unknown, details?: {
 }) => InternalError;
 declare const isInternalError: (error: unknown) => error is InternalError;
 
+declare const drizzlePgConfig: {
+    schema: string;
+    out: string;
+    dialect: "postgresql";
+    dbCredentials: {
+        url: string;
+    };
+    migrations: {
+        table: string;
+        schema: string;
+    };
+};
+
+declare const calculateExponentialBackoff: (attempts: number, baseDelaySeconds: number) => number;
+
 declare const RPCResponse: {
     /**
      * ✅ Constructs a successful RPC response.
@@ -252,63 +345,6 @@ declare const useResult: <T>(promise: Promise<T>) => Promise<Result<T>>;
  */
 declare const useResultSync: <T>(fn: () => T) => Result<T>;
 
-declare const calculateExponentialBackoff: (attempts: number, baseDelaySeconds: number) => number;
-
-interface AuditLogPayload<T> {
-    action: T;
-    actorId: string;
-    actorUsername?: string;
-    service: string;
-    entityId?: string;
-}
-
-interface Command<TAuditAction = string> {
-    handler: (db: DrizzleD1Database<Record<string, unknown>>) => CommandItem<TAuditAction>;
-}
-type CommandFactory<TParams = void, TAuditAction = string> = TParams extends void ? () => Command<TAuditAction> : (params: TParams) => Command<TAuditAction>;
-declare const defineCommand: <TParams = void, TAuditAction = string>(handler: (db: DrizzleD1Database<Record<string, unknown>>, params: TParams) => {
-    command: BatchItem<"sqlite">;
-    logPayload: CommandLogPayload<TAuditAction>;
-    id: string;
-}) => CommandFactory<TParams, TAuditAction>;
-
-declare class DatabaseTransaction<TAuditAction = string> {
-    private db;
-    private serviceName?;
-    private auditLogWriter?;
-    private commands;
-    private logs;
-    private ids;
-    constructor(db: DrizzleD1Database<Record<string, unknown>>, serviceName?: string | undefined, auditLogWriter?: ((logs: AuditLogPayload<TAuditAction>[], db: DrizzleD1Database<Record<string, unknown>>) => BatchItem<"sqlite">[]) | undefined);
-    enqueue<U extends Command<TAuditAction>, T extends Readonly<U> | Readonly<[U, ...U[]]>>(commands: T): string | string[] | undefined;
-    execute(commandItem: Command<TAuditAction>): Promise<void>;
-    executeAll(): Promise<void>;
-    getLogs(): readonly AuditLogPayload<TAuditAction>[];
-    getIds(): readonly string[];
-    getCommandsCount(): number;
-}
-
-type AuditLogTable = AnySQLiteTable | AnyPgTable;
-type AuditLogWriter<TAuditAction = string> = (logs: AuditLogPayload<TAuditAction>[], db: DrizzleD1Database<Record<string, unknown>>) => BatchItem<'sqlite'>[];
-/**
- * Creates an audit log writer function that inserts audit logs into a specified table
- *
- * @param table - The Drizzle table definition for audit logs
- * @returns A function that can be passed to DatabaseTransaction constructor
- *
- * @example
- * ```typescript
- * import { createAuditLogWriter } from '@develit-io/workers-sdk'
- * import { auditLogsTable } from './schema'
- *
- * const auditWriter = createAuditLogWriter(auditLogsTable)
- *
- * // Use in initializeDB
- * this.initializeDB(env.DB, schema, auditWriter)
- * ```
- */
-declare function createAuditLogWriter<TAuditAction = string>(table: AuditLogTable): AuditLogWriter<TAuditAction>;
-
 declare const service: (serviceName: string) => <T extends new (...args: any[]) => object>(constructor: T) => {
     new (...args: any[]): {
         name: string;
@@ -328,5 +364,4 @@ interface WithRetryCounterOptions {
 type AsyncMethod<TArgs extends unknown[] = unknown[], TResult = unknown> = (...args: TArgs) => Promise<TResult>;
 declare function cloudflareQueue<TArgs extends unknown[] = unknown[], TResult = unknown>(options: WithRetryCounterOptions): (target: unknown, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<AsyncMethod<TArgs, TResult>>) => void;
 
-export { DatabaseTransaction, RPCResponse, action, base, basePostgres, calculateExponentialBackoff, cloudflareQueue, createAuditLogWriter, createInternalError, defineCommand, develitWorker, drizzleConfig, first, firstOrError, handleAction, handleActionResponse, ibanZodSchema, isInternalError, service, swiftZodSchema, useResult, useResultSync, uuidv4 };
-export type { ActionExecution, ActionHandlerOptions, AuditLogWriter, Command, CommandLogPayload, DevelitWorkerMethods, GatewayResponse, IRPCResponse, IncludeRelation, InferResultType, InternalError, InternalErrorResponseStatus, ValidatedInput };
+export { type ActionExecution, type ActionHandlerOptions, type AuditLogWriter, type Command, type CommandLogPayload, DatabaseTransaction, type DevelitWorkerMethods, type GatewayResponse, type IRPCResponse, type IncludeRelation, type InferResultType, type InternalError, type InternalErrorResponseStatus, RPCResponse, type ValidatedInput, action, base, basePostgres, calculateExponentialBackoff, cloudflareQueue, createAuditLogWriter, createInternalError, defineCommand, develitWorker, drizzleD1Config, drizzlePgConfig, durableObjectNamespaceIdFromName, first, firstOrError, handleAction, handleActionResponse, ibanZodSchema, isInternalError, service, swiftZodSchema, useResult, useResultSync, uuidv4 };

package/dist/index.d.mts

@@ -8,7 +8,6 @@ import { StatusCodes, ReasonPhrases } from 'http-status-codes';
 export { ReasonPhrases as InternalResponsePhrase, StatusCodes as InternalResponseStatus } from 'http-status-codes';
 import * as z from 'zod/v4/core';
 import { Queue } from '@cloudflare/workers-types';
-import * as drizzle_kit from 'drizzle-kit';
 import { BatchItem } from 'drizzle-orm/batch';
 import { DrizzleD1Database } from 'drizzle-orm/d1';
 
@@ -162,7 +161,86 @@ type ValidatedInput<T extends z.$ZodType> = z.infer<T>;
  */
 type ActionExecution<TInput, TOutput> = TInput extends null ? () => Promise<TOutput> : (input: TInput) => Promise<TOutput>;
 
-declare const drizzleConfig: drizzle_kit.Config;
+interface AuditLogPayload<T> {
+    action: T;
+    actorId: string;
+    actorUsername?: string;
+    service: string;
+    entityId?: string;
+}
+
+type AuditLogTable = AnySQLiteTable | AnyPgTable;
+type AuditLogWriter<TAuditAction = string> = (logs: AuditLogPayload<TAuditAction>[], db: DrizzleD1Database<Record<string, unknown>>) => BatchItem<'sqlite'>[];
+/**
+ * Creates an audit log writer function that inserts audit logs into a specified table
+ *
+ * @param table - The Drizzle table definition for audit logs
+ * @returns A function that can be passed to DatabaseTransaction constructor
+ *
+ * @example
+ * ```typescript
+ * import { createAuditLogWriter } from '@develit-io/workers-sdk'
+ * import { auditLogsTable } from './schema'
+ *
+ * const auditWriter = createAuditLogWriter(auditLogsTable)
+ *
+ * // Use in initializeDB
+ * this.initializeDB(env.DB, schema, auditWriter)
+ * ```
+ */
+declare function createAuditLogWriter<TAuditAction = string>(table: AuditLogTable): AuditLogWriter<TAuditAction>;
+
+declare function durableObjectNamespaceIdFromName(uniqueKey: string, name: string): string;
+declare const drizzleD1Config: {
+    driver: string;
+    dbCredentials: {
+        accountId: string | undefined;
+        databaseId: string;
+        token: string | undefined;
+        url?: undefined;
+    };
+    schema: string;
+    out: string;
+    dialect: "sqlite";
+} | {
+    dbCredentials: {
+        url: string | undefined;
+        accountId?: undefined;
+        databaseId?: undefined;
+        token?: undefined;
+    };
+    driver?: undefined;
+    schema: string;
+    out: string;
+    dialect: "sqlite";
+};
+
+interface Command<TAuditAction = string> {
+    handler: (db: DrizzleD1Database<Record<string, unknown>>) => CommandItem<TAuditAction>;
+}
+type CommandFactory<TParams = void, TAuditAction = string> = TParams extends void ? () => Command<TAuditAction> : (params: TParams) => Command<TAuditAction>;
+declare const defineCommand: <TParams = void, TAuditAction = string>(handler: (db: DrizzleD1Database<Record<string, unknown>>, params: TParams) => {
+    command: BatchItem<"sqlite">;
+    logPayload: CommandLogPayload<TAuditAction>;
+    id: string;
+}) => CommandFactory<TParams, TAuditAction>;
+
+declare class DatabaseTransaction<TAuditAction = string> {
+    private db;
+    private serviceName?;
+    private auditLogWriter?;
+    private commands;
+    private logs;
+    private ids;
+    constructor(db: DrizzleD1Database<Record<string, unknown>>, serviceName?: string | undefined, auditLogWriter?: ((logs: AuditLogPayload<TAuditAction>[], db: DrizzleD1Database<Record<string, unknown>>) => BatchItem<"sqlite">[]) | undefined);
+    enqueue<U extends Command<TAuditAction>, T extends Readonly<U> | Readonly<[U, ...U[]]>>(commands: T): string | string[] | undefined;
+    execute(commandItem: Command<TAuditAction>): Promise<void>;
+    executeAll(): Promise<void>;
+    getLogs(): readonly AuditLogPayload<TAuditAction>[];
+    getIds(): readonly string[];
+    getCommandsCount(): number;
+}
+
 declare function first<T>(rows: T[]): T | undefined;
 declare function firstOrError<T>(rows: T[]): T;
 declare const uuidv4: () => `${string}-${string}-${string}-${string}-${string}`;
@@ -174,6 +252,21 @@ declare const createInternalError: (error: unknown, details?: {
 }) => InternalError;
 declare const isInternalError: (error: unknown) => error is InternalError;
 
+declare const drizzlePgConfig: {
+    schema: string;
+    out: string;
+    dialect: "postgresql";
+    dbCredentials: {
+        url: string;
+    };
+    migrations: {
+        table: string;
+        schema: string;
+    };
+};
+
+declare const calculateExponentialBackoff: (attempts: number, baseDelaySeconds: number) => number;
+
 declare const RPCResponse: {
     /**
      * ✅ Constructs a successful RPC response.
@@ -252,63 +345,6 @@ declare const useResult: <T>(promise: Promise<T>) => Promise<Result<T>>;
  */
 declare const useResultSync: <T>(fn: () => T) => Result<T>;
 
-declare const calculateExponentialBackoff: (attempts: number, baseDelaySeconds: number) => number;
-
-interface AuditLogPayload<T> {
-    action: T;
-    actorId: string;
-    actorUsername?: string;
-    service: string;
-    entityId?: string;
-}
-
-interface Command<TAuditAction = string> {
-    handler: (db: DrizzleD1Database<Record<string, unknown>>) => CommandItem<TAuditAction>;
-}
-type CommandFactory<TParams = void, TAuditAction = string> = TParams extends void ? () => Command<TAuditAction> : (params: TParams) => Command<TAuditAction>;
-declare const defineCommand: <TParams = void, TAuditAction = string>(handler: (db: DrizzleD1Database<Record<string, unknown>>, params: TParams) => {
-    command: BatchItem<"sqlite">;
-    logPayload: CommandLogPayload<TAuditAction>;
-    id: string;
-}) => CommandFactory<TParams, TAuditAction>;
-
-declare class DatabaseTransaction<TAuditAction = string> {
-    private db;
-    private serviceName?;
-    private auditLogWriter?;
-    private commands;
-    private logs;
-    private ids;
-    constructor(db: DrizzleD1Database<Record<string, unknown>>, serviceName?: string | undefined, auditLogWriter?: ((logs: AuditLogPayload<TAuditAction>[], db: DrizzleD1Database<Record<string, unknown>>) => BatchItem<"sqlite">[]) | undefined);
-    enqueue<U extends Command<TAuditAction>, T extends Readonly<U> | Readonly<[U, ...U[]]>>(commands: T): string | string[] | undefined;
-    execute(commandItem: Command<TAuditAction>): Promise<void>;
-    executeAll(): Promise<void>;
-    getLogs(): readonly AuditLogPayload<TAuditAction>[];
-    getIds(): readonly string[];
-    getCommandsCount(): number;
-}
-
-type AuditLogTable = AnySQLiteTable | AnyPgTable;
-type AuditLogWriter<TAuditAction = string> = (logs: AuditLogPayload<TAuditAction>[], db: DrizzleD1Database<Record<string, unknown>>) => BatchItem<'sqlite'>[];
-/**
- * Creates an audit log writer function that inserts audit logs into a specified table
- *
- * @param table - The Drizzle table definition for audit logs
- * @returns A function that can be passed to DatabaseTransaction constructor
- *
- * @example
- * ```typescript
- * import { createAuditLogWriter } from '@develit-io/workers-sdk'
- * import { auditLogsTable } from './schema'
- *
- * const auditWriter = createAuditLogWriter(auditLogsTable)
- *
- * // Use in initializeDB
- * this.initializeDB(env.DB, schema, auditWriter)
- * ```
- */
-declare function createAuditLogWriter<TAuditAction = string>(table: AuditLogTable): AuditLogWriter<TAuditAction>;
-
 declare const service: (serviceName: string) => <T extends new (...args: any[]) => object>(constructor: T) => {
     new (...args: any[]): {
         name: string;
@@ -328,5 +364,4 @@ interface WithRetryCounterOptions {
 type AsyncMethod<TArgs extends unknown[] = unknown[], TResult = unknown> = (...args: TArgs) => Promise<TResult>;
 declare function cloudflareQueue<TArgs extends unknown[] = unknown[], TResult = unknown>(options: WithRetryCounterOptions): (target: unknown, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<AsyncMethod<TArgs, TResult>>) => void;
 
-export { DatabaseTransaction, RPCResponse, action, base, basePostgres, calculateExponentialBackoff, cloudflareQueue, createAuditLogWriter, createInternalError, defineCommand, develitWorker, drizzleConfig, first, firstOrError, handleAction, handleActionResponse, ibanZodSchema, isInternalError, service, swiftZodSchema, useResult, useResultSync, uuidv4 };
-export type { ActionExecution, ActionHandlerOptions, AuditLogWriter, Command, CommandLogPayload, DevelitWorkerMethods, GatewayResponse, IRPCResponse, IncludeRelation, InferResultType, InternalError, InternalErrorResponseStatus, ValidatedInput };
+export { type ActionExecution, type ActionHandlerOptions, type AuditLogWriter, type Command, type CommandLogPayload, DatabaseTransaction, type DevelitWorkerMethods, type GatewayResponse, type IRPCResponse, type IncludeRelation, type InferResultType, type InternalError, type InternalErrorResponseStatus, RPCResponse, type ValidatedInput, action, base, basePostgres, calculateExponentialBackoff, cloudflareQueue, createAuditLogWriter, createInternalError, defineCommand, develitWorker, drizzleD1Config, drizzlePgConfig, durableObjectNamespaceIdFromName, first, firstOrError, handleAction, handleActionResponse, ibanZodSchema, isInternalError, service, swiftZodSchema, useResult, useResultSync, uuidv4 };

package/dist/index.d.ts

@@ -8,7 +8,6 @@ import { StatusCodes, ReasonPhrases } from 'http-status-codes';
 export { ReasonPhrases as InternalResponsePhrase, StatusCodes as InternalResponseStatus } from 'http-status-codes';
 import * as z from 'zod/v4/core';
 import { Queue } from '@cloudflare/workers-types';
-import * as drizzle_kit from 'drizzle-kit';
 import { BatchItem } from 'drizzle-orm/batch';
 import { DrizzleD1Database } from 'drizzle-orm/d1';
 
@@ -162,7 +161,86 @@ type ValidatedInput<T extends z.$ZodType> = z.infer<T>;
  */
 type ActionExecution<TInput, TOutput> = TInput extends null ? () => Promise<TOutput> : (input: TInput) => Promise<TOutput>;
 
-declare const drizzleConfig: drizzle_kit.Config;
+interface AuditLogPayload<T> {
+    action: T;
+    actorId: string;
+    actorUsername?: string;
+    service: string;
+    entityId?: string;
+}
+
+type AuditLogTable = AnySQLiteTable | AnyPgTable;
+type AuditLogWriter<TAuditAction = string> = (logs: AuditLogPayload<TAuditAction>[], db: DrizzleD1Database<Record<string, unknown>>) => BatchItem<'sqlite'>[];
+/**
+ * Creates an audit log writer function that inserts audit logs into a specified table
+ *
+ * @param table - The Drizzle table definition for audit logs
+ * @returns A function that can be passed to DatabaseTransaction constructor
+ *
+ * @example
+ * ```typescript
+ * import { createAuditLogWriter } from '@develit-io/workers-sdk'
+ * import { auditLogsTable } from './schema'
+ *
+ * const auditWriter = createAuditLogWriter(auditLogsTable)
+ *
+ * // Use in initializeDB
+ * this.initializeDB(env.DB, schema, auditWriter)
+ * ```
+ */
+declare function createAuditLogWriter<TAuditAction = string>(table: AuditLogTable): AuditLogWriter<TAuditAction>;
+
+declare function durableObjectNamespaceIdFromName(uniqueKey: string, name: string): string;
+declare const drizzleD1Config: {
+    driver: string;
+    dbCredentials: {
+        accountId: string | undefined;
+        databaseId: string;
+        token: string | undefined;
+        url?: undefined;
+    };
+    schema: string;
+    out: string;
+    dialect: "sqlite";
+} | {
+    dbCredentials: {
+        url: string | undefined;
+        accountId?: undefined;
+        databaseId?: undefined;
+        token?: undefined;
+    };
+    driver?: undefined;
+    schema: string;
+    out: string;
+    dialect: "sqlite";
+};
+
+interface Command<TAuditAction = string> {
+    handler: (db: DrizzleD1Database<Record<string, unknown>>) => CommandItem<TAuditAction>;
+}
+type CommandFactory<TParams = void, TAuditAction = string> = TParams extends void ? () => Command<TAuditAction> : (params: TParams) => Command<TAuditAction>;
+declare const defineCommand: <TParams = void, TAuditAction = string>(handler: (db: DrizzleD1Database<Record<string, unknown>>, params: TParams) => {
+    command: BatchItem<"sqlite">;
+    logPayload: CommandLogPayload<TAuditAction>;
+    id: string;
+}) => CommandFactory<TParams, TAuditAction>;
+
+declare class DatabaseTransaction<TAuditAction = string> {
+    private db;
+    private serviceName?;
+    private auditLogWriter?;
+    private commands;
+    private logs;
+    private ids;
+    constructor(db: DrizzleD1Database<Record<string, unknown>>, serviceName?: string | undefined, auditLogWriter?: ((logs: AuditLogPayload<TAuditAction>[], db: DrizzleD1Database<Record<string, unknown>>) => BatchItem<"sqlite">[]) | undefined);
+    enqueue<U extends Command<TAuditAction>, T extends Readonly<U> | Readonly<[U, ...U[]]>>(commands: T): string | string[] | undefined;
+    execute(commandItem: Command<TAuditAction>): Promise<void>;
+    executeAll(): Promise<void>;
+    getLogs(): readonly AuditLogPayload<TAuditAction>[];
+    getIds(): readonly string[];
+    getCommandsCount(): number;
+}
+
 declare function first<T>(rows: T[]): T | undefined;
 declare function firstOrError<T>(rows: T[]): T;
 declare const uuidv4: () => `${string}-${string}-${string}-${string}-${string}`;
@@ -174,6 +252,21 @@ declare const createInternalError: (error: unknown, details?: {
 }) => InternalError;
 declare const isInternalError: (error: unknown) => error is InternalError;
 
+declare const drizzlePgConfig: {
+    schema: string;
+    out: string;
+    dialect: "postgresql";
+    dbCredentials: {
+        url: string;
+    };
+    migrations: {
+        table: string;
+        schema: string;
+    };
+};
+
+declare const calculateExponentialBackoff: (attempts: number, baseDelaySeconds: number) => number;
+
 declare const RPCResponse: {
     /**
      * ✅ Constructs a successful RPC response.
@@ -252,63 +345,6 @@ declare const useResult: <T>(promise: Promise<T>) => Promise<Result<T>>;
  */
 declare const useResultSync: <T>(fn: () => T) => Result<T>;
 
-declare const calculateExponentialBackoff: (attempts: number, baseDelaySeconds: number) => number;
-
-interface AuditLogPayload<T> {
-    action: T;
-    actorId: string;
-    actorUsername?: string;
-    service: string;
-    entityId?: string;
-}
-
-interface Command<TAuditAction = string> {
-    handler: (db: DrizzleD1Database<Record<string, unknown>>) => CommandItem<TAuditAction>;
-}
-type CommandFactory<TParams = void, TAuditAction = string> = TParams extends void ? () => Command<TAuditAction> : (params: TParams) => Command<TAuditAction>;
-declare const defineCommand: <TParams = void, TAuditAction = string>(handler: (db: DrizzleD1Database<Record<string, unknown>>, params: TParams) => {
-    command: BatchItem<"sqlite">;
-    logPayload: CommandLogPayload<TAuditAction>;
-    id: string;
-}) => CommandFactory<TParams, TAuditAction>;
-
-declare class DatabaseTransaction<TAuditAction = string> {
-    private db;
-    private serviceName?;
-    private auditLogWriter?;
-    private commands;
-    private logs;
-    private ids;
-    constructor(db: DrizzleD1Database<Record<string, unknown>>, serviceName?: string | undefined, auditLogWriter?: ((logs: AuditLogPayload<TAuditAction>[], db: DrizzleD1Database<Record<string, unknown>>) => BatchItem<"sqlite">[]) | undefined);
-    enqueue<U extends Command<TAuditAction>, T extends Readonly<U> | Readonly<[U, ...U[]]>>(commands: T): string | string[] | undefined;
-    execute(commandItem: Command<TAuditAction>): Promise<void>;
-    executeAll(): Promise<void>;
-    getLogs(): readonly AuditLogPayload<TAuditAction>[];
-    getIds(): readonly string[];
-    getCommandsCount(): number;
-}
-
-type AuditLogTable = AnySQLiteTable | AnyPgTable;
-type AuditLogWriter<TAuditAction = string> = (logs: AuditLogPayload<TAuditAction>[], db: DrizzleD1Database<Record<string, unknown>>) => BatchItem<'sqlite'>[];
-/**
- * Creates an audit log writer function that inserts audit logs into a specified table
- *
- * @param table - The Drizzle table definition for audit logs
- * @returns A function that can be passed to DatabaseTransaction constructor
- *
- * @example
- * ```typescript
- * import { createAuditLogWriter } from '@develit-io/workers-sdk'
- * import { auditLogsTable } from './schema'
- *
- * const auditWriter = createAuditLogWriter(auditLogsTable)
- *
- * // Use in initializeDB
- * this.initializeDB(env.DB, schema, auditWriter)
- * ```
- */
-declare function createAuditLogWriter<TAuditAction = string>(table: AuditLogTable): AuditLogWriter<TAuditAction>;
-
 declare const service: (serviceName: string) => <T extends new (...args: any[]) => object>(constructor: T) => {
     new (...args: any[]): {
         name: string;
@@ -328,5 +364,4 @@ interface WithRetryCounterOptions {
 type AsyncMethod<TArgs extends unknown[] = unknown[], TResult = unknown> = (...args: TArgs) => Promise<TResult>;
 declare function cloudflareQueue<TArgs extends unknown[] = unknown[], TResult = unknown>(options: WithRetryCounterOptions): (target: unknown, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<AsyncMethod<TArgs, TResult>>) => void;
 
-export { DatabaseTransaction, RPCResponse, action, base, basePostgres, calculateExponentialBackoff, cloudflareQueue, createAuditLogWriter, createInternalError, defineCommand, develitWorker, drizzleConfig, first, firstOrError, handleAction, handleActionResponse, ibanZodSchema, isInternalError, service, swiftZodSchema, useResult, useResultSync, uuidv4 };
-export type { ActionExecution, ActionHandlerOptions, AuditLogWriter, Command, CommandLogPayload, DevelitWorkerMethods, GatewayResponse, IRPCResponse, IncludeRelation, InferResultType, InternalError, InternalErrorResponseStatus, ValidatedInput };
+export { type ActionExecution, type ActionHandlerOptions, type AuditLogWriter, type Command, type CommandLogPayload, DatabaseTransaction, type DevelitWorkerMethods, type GatewayResponse, type IRPCResponse, type IncludeRelation, type InferResultType, type InternalError, type InternalErrorResponseStatus, RPCResponse, type ValidatedInput, action, base, basePostgres, calculateExponentialBackoff, cloudflareQueue, createAuditLogWriter, createInternalError, defineCommand, develitWorker, drizzleD1Config, drizzlePgConfig, durableObjectNamespaceIdFromName, first, firstOrError, handleAction, handleActionResponse, ibanZodSchema, isInternalError, service, swiftZodSchema, useResult, useResultSync, uuidv4 };

package/dist/index.mjs

@@ -5,7 +5,10 @@ import 'http-status-codes';
 import * as z from 'zod/v4/core';
 import { createError } from 'h3';
 import { consola } from 'consola';
-import { defineConfig } from 'drizzle-kit';
+import fs from 'fs';
+import crypto$1 from 'node:crypto';
+import path from 'path';
+import { parse } from 'jsonc-parser';
 import superjson from 'superjson';
 
 const base = {
@@ -191,28 +194,116 @@ async function handleAction(worker, input, options = {}, actionExecution) {
   }
 }
 
-const drizzleConfig = defineConfig({
-  dialect: "sqlite",
-  schema: "./src/database/schema/",
-  out: "./src/database/migrations/"
-});
-function first(rows) {
-  return rows.length > 0 ? rows[0] : void 0;
-}
-function firstOrError(rows) {
-  if (rows.length === 0) {
-    throw new Error("Query did not return any data.");
-  }
-  return rows[0];
+const asNonEmpty = (arr) => {
+  return arr.length > 0 ? [arr[0], ...arr.slice(1)] : null;
+};
+
+function createAuditLogWriter(table) {
+  return (logs, db) => {
+    if (logs.length === 0) return [];
+    const auditRecords = logs.map((log) => ({
+      ...log,
+      createdAt: /* @__PURE__ */ new Date(),
+      id: crypto.randomUUID()
+    }));
+    return [db.insert(table).values(auditRecords)];
+  };
 }
-const uuidv4 = () => crypto.randomUUID();
 
-const calculateExponentialBackoff = (attempts, baseDelaySeconds) => {
-  return baseDelaySeconds ** attempts;
+function durableObjectNamespaceIdFromName(uniqueKey, name) {
+  const key = crypto$1.createHash("sha256").update(uniqueKey).digest();
+  const nameHmac = crypto$1.createHmac("sha256", key).update(name).digest().subarray(0, 16);
+  const hmac = crypto$1.createHmac("sha256", key).update(nameHmac).digest().subarray(0, 16);
+  return Buffer.concat([nameHmac, hmac]).toString("hex");
+}
+const getDatabaseIdFromWrangler = () => {
+  try {
+    const wranglerPath = path.resolve("./wrangler.jsonc");
+    const wranglerContent = fs.readFileSync(wranglerPath, "utf-8");
+    const errors = [];
+    const config = parse(wranglerContent, errors, { allowTrailingComma: true });
+    if (errors.length) {
+      throw new Error("Invalid JSONC in wrangler.jsonc");
+    }
+    const environment = process.env.ENVIRONMENT || "localhost";
+    let databaseId;
+    if (environment !== "localhost" && config.env?.[environment]) {
+      databaseId = config.env[environment].d1_databases?.[0]?.database_id;
+      console.log(
+        `Using database_id for environment '${environment}': ${databaseId}`
+      );
+    }
+    if (!databaseId) {
+      databaseId = config.d1_databases?.[0]?.database_id;
+      console.log(
+        `Using default database_id for environment '${environment}': ${databaseId}`
+      );
+    }
+    if (!databaseId) {
+      throw new Error("database_id not found in wrangler.jsonc");
+    }
+    return databaseId;
+  } catch (err) {
+    console.warn(
+      `Warning: Could not read database_id from wrangler.jsonc: ${err}`
+    );
+  }
 };
-
-const asNonEmpty = (arr) => {
-  return arr.length > 0 ? [arr[0], ...arr.slice(1)] : null;
+const isRemoteEnvironment = () => {
+  const environment = process.env.ENVIRONMENT;
+  return environment && environment !== "localhost";
+};
+const getLocalD1 = (databaseId) => {
+  const name = durableObjectNamespaceIdFromName(
+    "miniflare-D1DatabaseObject",
+    databaseId
+  );
+  const searchPaths = [
+    path.resolve("../../.wrangler"),
+    // Root of monorepo
+    path.resolve("./.wrangler")
+    // Current directory
+  ];
+  for (const basePath of searchPaths) {
+    try {
+      const dbFile = fs.readdirSync(basePath, { encoding: "utf-8", recursive: true }).find((f) => f.includes(name));
+      if (dbFile) {
+        const url = path.resolve(basePath, dbFile);
+        console.log(`Found D1 database at: ${url}`);
+        return url;
+      } else {
+        throw new Error(`No D1 database file found in ${basePath}`);
+      }
+    } catch {
+      console.warn(`Could not search in ${basePath}`);
+      continue;
+    }
+  }
+};
+const getCredentials = () => {
+  const databaseId = getDatabaseIdFromWrangler() ?? "";
+  if (isRemoteEnvironment()) {
+    return {
+      driver: "d1-http",
+      dbCredentials: {
+        accountId: process.env.CLOUDFLARE_ACCOUNT_ID,
+        databaseId,
+        token: process.env.CLOUDFLARE_API_TOKEN
+      }
+    };
+  } else {
+    return {
+      dbCredentials: {
+        url: getLocalD1(databaseId)
+      }
+    };
+  }
+};
+const drizzleD1Config = {
+  schema: "./src/database/schema/",
+  out: "./src/database/migrations/",
+  dialect: "sqlite",
+  ...getCredentials()
 };
 
 class DatabaseTransaction {
@@ -277,17 +368,33 @@ const defineCommand = (handler) => {
   });
 };
 
-function createAuditLogWriter(table) {
-  return (logs, db) => {
-    if (logs.length === 0) return [];
-    const auditRecords = logs.map((log) => ({
-      ...log,
-      createdAt: /* @__PURE__ */ new Date(),
-      id: crypto.randomUUID()
-    }));
-    return [db.insert(table).values(auditRecords)];
-  };
+function first(rows) {
+  return rows.length > 0 ? rows[0] : void 0;
+}
+function firstOrError(rows) {
+  if (rows.length === 0) {
+    throw new Error("Query did not return any data.");
+  }
+  return rows[0];
 }
+const uuidv4 = () => crypto.randomUUID();
+
+const drizzlePgConfig = {
+  schema: "./src/database/schema/",
+  out: "./src/database/migrations/",
+  dialect: "postgresql",
+  dbCredentials: {
+    url: process.env.DATABASE_URL
+  },
+  migrations: {
+    table: "__drizzle_migrations",
+    schema: "public"
+  }
+};
+
+const calculateExponentialBackoff = (attempts, baseDelaySeconds) => {
+  return baseDelaySeconds ** attempts;
+};
 
 const service = (serviceName) => {
   return function(constructor) {
@@ -425,4 +532,4 @@ function develitWorker(Worker) {
   return DevelitWorker;
 }
 
-export { DatabaseTransaction, RPCResponse, action, base, basePostgres, calculateExponentialBackoff, cloudflareQueue, createAuditLogWriter, createInternalError, defineCommand, develitWorker, drizzleConfig, first, firstOrError, handleAction, handleActionResponse, ibanZodSchema, isInternalError, service, swiftZodSchema, useResult, useResultSync, uuidv4 };
+export { DatabaseTransaction, RPCResponse, action, base, basePostgres, calculateExponentialBackoff, cloudflareQueue, createAuditLogWriter, createInternalError, defineCommand, develitWorker, drizzleD1Config, drizzlePgConfig, durableObjectNamespaceIdFromName, first, firstOrError, handleAction, handleActionResponse, ibanZodSchema, isInternalError, service, swiftZodSchema, useResult, useResultSync, uuidv4 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@develit-io/backend-sdk",
-  "version": "5.6.0",
+  "version": "5.8.0",
   "description": "Develit Backend SDK",
   "author": "Develit.io",
   "license": "ISC",
@@ -11,6 +11,8 @@
     "lint": "biome check",
     "lint:fix": "biome check --fix",
     "build": "unbuild",
+    "test": "vitest",
+    "test:unit": "vitest test/unit",
     "changelogen": "bunx changelogen@latest --bump",
     "release": "bun run build && bunx changelogen@latest --release --push && npm publish --access public"
   },
@@ -31,9 +33,13 @@
     "drizzle-orm": "^0.44.3",
     "h3": "^1.15.3",
     "http-status-codes": "2.3.0",
+    "jsonc-parser": "^3.3.1",
     "superjson": "^2.2.2"
   },
   "peerDependencies": {
     "zod": "^4.0.11"
+  },
+  "devDependencies": {
+    "vitest": "^1.6.0"
   }
 }