@develit-io/backend-sdk 5.30.3 → 5.30.5

package/dist/index.cjs

@@ -1,783 +0,0 @@
-'use strict';
-
-const drizzleOrm = require('drizzle-orm');
-const pgCore = require('drizzle-orm/pg-core');
-const sqliteCore = require('drizzle-orm/sqlite-core');
-const generalCodes = require('@develit-io/general-codes');
-const environment_consts = require('./shared/backend-sdk.BdcrYpFD.cjs');
-const z = require('zod/v4/core');
-require('http-status-codes');
-const h3 = require('h3');
-const fs = require('node:fs');
-const crypto$1 = require('node:crypto');
-const path = require('node:path');
-const commentJson = require('comment-json');
-const superjson = require('superjson');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
-
-function _interopNamespaceCompat(e) {
-  if (e && typeof e === 'object' && 'default' in e) return e;
-  const n = Object.create(null);
-  if (e) {
-    for (const k in e) {
-      n[k] = e[k];
-    }
-  }
-  n.default = e;
-  return n;
-}
-
-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 = {
-  id: sqliteCore.text("id").primaryKey(),
-  createdAt: sqliteCore.integer("created_at", { mode: "timestamp_ms" }).default(
-    drizzleOrm.sql`(unixepoch('subsec') * 1000)`
-  ),
-  updatedAt: sqliteCore.integer("updated_at", { mode: "timestamp_ms" }).default(drizzleOrm.sql`(unixepoch('subsec') * 1000)`).$onUpdate(() => /* @__PURE__ */ new Date()),
-  deletedAt: sqliteCore.integer("deleted_at", { mode: "timestamp_ms" }).default(drizzleOrm.sql`null`)
-};
-const basePostgres = {
-  id: pgCore.uuid("id").primaryKey(),
-  createdAt: pgCore.timestamp("created_at", { mode: "date", withTimezone: false }).defaultNow().notNull(),
-  updatedAt: pgCore.timestamp("updated_at", { mode: "date", withTimezone: false }).defaultNow().notNull().$onUpdate(() => /* @__PURE__ */ new Date()),
-  deletedAt: pgCore.timestamp("deleted_at", {
-    mode: "date",
-    withTimezone: false
-  }).default(drizzleOrm.sql`null`)
-};
-
-const bankAccount = {
-  holderName: sqliteCore.text("holder_name").notNull(),
-  number: sqliteCore.text("number").notNull(),
-  bankCode: sqliteCore.text("bank_code", { enum: generalCodes.BANK_CODES }).notNull(),
-  iban: sqliteCore.text("iban").notNull(),
-  bic: sqliteCore.text("bic").notNull(),
-  currency: sqliteCore.text("currency", { enum: generalCodes.CURRENCY_CODES }).notNull(),
-  countryCode: sqliteCore.text("country_code", { enum: generalCodes.COUNTRY_CODES_2 }).notNull()
-};
-const bankAccountCurrencyEnum = pgCore.pgEnum("currency", generalCodes.CURRENCY_CODES);
-const bankAccountCountryCodeEnum = pgCore.pgEnum(
-  "country_code",
-  generalCodes.COUNTRY_CODES_2
-);
-const bankAccountBankCodeEnum = pgCore.pgEnum("bank_code", generalCodes.BANK_CODES);
-const bankAccountPostgres = {
-  holderName: pgCore.text("holder_name").notNull(),
-  number: pgCore.text("number").notNull(),
-  bankCode: bankAccountBankCodeEnum().$type().notNull(),
-  iban: pgCore.text("iban").notNull(),
-  bic: pgCore.text("bic").notNull(),
-  currency: bankAccountCurrencyEnum().$type().notNull(),
-  countryCode: bankAccountCountryCodeEnum().$type().notNull()
-};
-
-const ibanZodSchema = new z__namespace.$ZodString({
-  type: "string",
-  checks: [
-    new z__namespace.$ZodCheckMinLength({
-      check: "min_length",
-      minimum: 1
-    }),
-    new z__namespace.$ZodCheckRegex({
-      check: "string_format",
-      format: "regex",
-      pattern: /^[A-Z]{2}[0-9]{2}[A-Z0-9]{11,30}$/
-    })
-  ]
-});
-const swiftZodSchema = new z__namespace.$ZodString({
-  type: "string",
-  checks: [
-    new z__namespace.$ZodCheckMinLength({
-      check: "min_length",
-      minimum: 1
-    }),
-    new z__namespace.$ZodCheckRegex({
-      check: "string_format",
-      format: "regex",
-      pattern: /^[A-Z]{6}[A-Z0-9]{2}([A-Z0-9]{3})?$/
-    })
-  ]
-});
-
-const paginationQuerySchema = new z__namespace.$ZodObject({
-  type: "object",
-  shape: {
-    page: new z__namespace.$ZodDefault({
-      type: "default",
-      innerType: new z__namespace.$ZodNumber({
-        type: "number",
-        coerce: true
-      }),
-      defaultValue: () => 1
-    }),
-    limit: new z__namespace.$ZodDefault({
-      type: "default",
-      innerType: new z__namespace.$ZodNumber({
-        type: "number",
-        coerce: true
-      }),
-      defaultValue: () => 20
-    }),
-    sort: new z__namespace.$ZodDefault({
-      type: "default",
-      innerType: new z__namespace.$ZodObject({
-        type: "object",
-        shape: {
-          column: new z__namespace.$ZodDefault({
-            type: "default",
-            innerType: new z__namespace.$ZodEnum({
-              type: "enum",
-              entries: {
-                createdAt: "createdAt",
-                updatedAt: "updatedAt",
-                deletedAt: "deletedAt"
-              }
-            }),
-            defaultValue: () => "updatedAt"
-          }),
-          direction: new z__namespace.$ZodDefault({
-            type: "default",
-            innerType: new z__namespace.$ZodEnum({
-              type: "enum",
-              entries: {
-                asc: "asc",
-                desc: "desc"
-              }
-            }),
-            defaultValue: () => "desc"
-          })
-        }
-      }),
-      defaultValue: () => ({ column: "updatedAt", direction: "desc" })
-    })
-  }
-});
-const paginationSchema = new z__namespace.$ZodObject({
-  type: "object",
-  shape: {
-    page: new z__namespace.$ZodNumber({
-      type: "number"
-    }),
-    limit: new z__namespace.$ZodNumber({
-      type: "number"
-    }),
-    sort: new z__namespace.$ZodObject({
-      type: "object",
-      shape: {
-        column: new z__namespace.$ZodEnum({
-          type: "enum",
-          entries: {
-            createdAt: "createdAt",
-            updatedAt: "updatedAt",
-            deletedAt: "deletedAt"
-          }
-        }),
-        direction: new z__namespace.$ZodEnum({
-          type: "enum",
-          entries: {
-            asc: "asc",
-            desc: "desc"
-          }
-        })
-      }
-    })
-  }
-});
-
-const handleActionResponse = ({
-  error,
-  status,
-  message,
-  data
-}) => {
-  if (error) {
-    throw h3.createError({ status, message });
-  }
-  if (data === void 0 || data === null) {
-    throw h3.createError({
-      statusCode: 500,
-      message: "Could not process the request. (ACTION_RESPONSE_FAILED)"
-    });
-  }
-  return data;
-};
-
-const createInternalError = (error, details) => {
-  return {
-    status: details?.status || 500,
-    code: details?.code || "UNKNOWN_ERROR",
-    message: details?.message || (error instanceof Error ? error.message : "An unexpected error occurred.")
-  };
-};
-const isInternalError = (error) => {
-  return typeof error === "object" && error !== null && "message" in error && "code" in error;
-};
-
-const RPCResponse = {
-  /**
-   * ✅ Constructs a successful RPC response.
-   *
-   * This method wraps the provided data in a standardized response format,
-   * ensuring consistency across API responses.
-   *
-   * @template T - The type of the response data.
-   * @param message - Response message
-   * @param detail - Optional -> Contains data and status code
-   * @returns An `IRPCResponse<T>` with the provided data and no error.
-   */
-  ok(message, detail) {
-    return {
-      status: detail?.status || 200,
-      data: detail?.data,
-      error: false,
-      message
-    };
-  },
-  /**
-   * ❌ Constructs a generic service error response.
-   *
-   * This method logs the error and returns a standardized error response.
-   *
-   * @template T - The expected response type (typically ignored in errors).
-   * @param error - An `RPCError` containing error details.
-   * @returns An `IRPCResponse<T>` with `null` data and the provided error.
-   */
-  serviceError(error) {
-    console.error(error.message);
-    return {
-      status: error.status,
-      message: error.message,
-      data: null,
-      error: true
-    };
-  },
-  /**
-   * ❌ Constructs a validation error response (HTTP 400).
-   *
-   * This is a convenience method for returning validation errors.
-   * It internally delegates to `serviceError()`.
-   *
-   * @template T - The expected response type (typically ignored in errors).
-   * @param error - An `RPCError` representing a validation failure.
-   * @returns An `IRPCResponse<T>` with `null` data and the provided error.
-   */
-  validationError(error) {
-    return RPCResponse.serviceError(error);
-  }
-};
-
-const useResult = async (promise) => {
-  try {
-    return [await promise, null];
-  } catch (error) {
-    return [null, isInternalError(error) ? error : createInternalError(error)];
-  }
-};
-const useResultSync = (fn) => {
-  try {
-    return [fn(), null];
-  } catch (error) {
-    return [null, isInternalError(error) ? error : createInternalError(error)];
-  }
-};
-
-async function handleAction(worker, input, options = {}, actionExecution) {
-  const {
-    successMessage = "Operation completed successfully.",
-    logOutputTransform,
-    logInputTransform,
-    skipValidation = false,
-    skipLogging = false
-  } = options;
-  try {
-    if (!skipLogging && input) {
-      const inputToLog = logInputTransform ? logInputTransform(input.data) : input;
-      worker.logInput(inputToLog);
-    }
-    let validatedInput = input?.data || null;
-    if (!skipValidation && input) {
-      validatedInput = worker.handleInput({
-        input: input.data,
-        schema: input.schema
-      });
-    }
-    const [data, error] = await useResult(
-      validatedInput ? actionExecution(validatedInput) : actionExecution()
-    );
-    if (error) {
-      worker.logError(error);
-      return RPCResponse.serviceError(error);
-    }
-    if (!skipLogging) {
-      const outputToLog = logOutputTransform ? logOutputTransform(data) : data;
-      worker.logOutput(outputToLog);
-    }
-    return RPCResponse.ok(successMessage, { data });
-  } catch (error) {
-    const internalError = createInternalError(error);
-    worker.logError(internalError);
-    return RPCResponse.serviceError(internalError);
-  }
-}
-
-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)];
-  };
-}
-
-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 isRemoteEnvironment = () => {
-  const environment = process.env.ENVIRONMENT;
-  return environment && environment !== "localhost";
-};
-function derivePortFromId(id, base = 4e3, range = 1e4) {
-  let hash = 0;
-  for (let i = 0; i < id.length; i++) {
-    hash = hash * 31 + id.charCodeAt(i) >>> 0;
-  }
-  return base + hash % range;
-}
-
-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 getD1DatabaseIdFromWrangler = () => {
-  try {
-    const wranglerPath = path__default.resolve("./wrangler.jsonc");
-    const wranglerContent = fs__default.readFileSync(wranglerPath, "utf-8");
-    const config = commentJson.parse(wranglerContent);
-    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 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 getD1Credentials = () => {
-  const environment = process.env.ENVIRONMENT;
-  if (environment === "localhost") {
-    return {};
-  }
-  const databaseId = getD1DatabaseIdFromWrangler() ?? "";
-  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 getDrizzleD1Config = () => ({
-  schema: "./src/database/schema/",
-  out: "./src/database/migrations/",
-  dialect: "sqlite",
-  ...getD1Credentials()
-});
-
-class DatabaseTransaction {
-  constructor(db, serviceName, auditLogWriter) {
-    this.db = db;
-    this.serviceName = serviceName;
-    this.auditLogWriter = auditLogWriter;
-  }
-  commands = [];
-  logs = [];
-  ids = [];
-  enqueue(commands) {
-    return (Array.isArray(commands) ? commands : [commands]).map((cmd) => {
-      const commandItem = cmd.handler(this.db);
-      const auditLogPayload = {
-        ...commandItem.logPayload,
-        service: this.serviceName || "unknown-service"
-      };
-      this.commands.push(commandItem.command);
-      this.logs.push(auditLogPayload);
-      if (commandItem.id) {
-        this.ids.push(commandItem.id);
-      }
-      return commandItem;
-    }).reduce((acc, curr) => {
-      acc.push(curr.id);
-      return acc;
-    }, []);
-  }
-  async execute(commandItem) {
-    this.enqueue(commandItem);
-    await this.executeAll();
-  }
-  async executeAll() {
-    let allCommands = [...this.commands];
-    if (this.auditLogWriter && this.logs.length > 0) {
-      const auditCommands = this.auditLogWriter(this.logs, this.db);
-      allCommands.push(...auditCommands);
-    }
-    const batchItems = asNonEmpty(allCommands);
-    if (batchItems) {
-      await this.db.batch(batchItems);
-    }
-    this.commands = [];
-    this.logs = [];
-    this.ids = [];
-  }
-  getLogs() {
-    return [...this.logs];
-  }
-  getIds() {
-    return [...this.ids];
-  }
-  getCommandsCount() {
-    return this.commands.length;
-  }
-}
-
-const defineCommand = (handler) => {
-  return ((params) => ({
-    handler: (db) => handler(db, params)
-  }));
-};
-
-async function useFetch(url, { parseAs = "json", ...options } = {}) {
-  const [response, fetchError] = await useResult(fetch(url, options));
-  if (fetchError || !response) {
-    return [null, createInternalError(fetchError, { code: "NETWORK_ERROR" })];
-  }
-  const parsers = {
-    json: () => response.json(),
-    text: () => response.text(),
-    blob: () => response.blob()
-  };
-  const [body, parseError] = await useResult(parsers[parseAs]());
-  if (!response.ok) {
-    return [
-      null,
-      createInternalError(parseError, {
-        message: body?.message ?? response.statusText,
-        code: "HTTP_ERROR",
-        status: response.status
-      })
-    ];
-  }
-  if (parseError) {
-    return [
-      null,
-      createInternalError(parseError, {
-        code: "PARSE_ERROR",
-        status: response.status
-      })
-    ];
-  }
-  return [body, null];
-}
-
-const getPgLocalConnectionString = (id) => `postgres://db_user:db_password@127.0.0.1:${derivePortFromId(id)}/db`;
-const getPgDatabaseIdFromWrangler = () => {
-  try {
-    const wranglerPath = path__default.resolve("./wrangler.jsonc");
-    const wranglerContent = fs__default.readFileSync(wranglerPath, "utf-8");
-    const config = commentJson.parse(wranglerContent);
-    if (!config.name) {
-      throw new Error('Missing "name" in wrangler.jsonc');
-    }
-    const databaseId = `${config.name}-db`;
-    console.log(`Using databaseId derived from wrangler name: ${databaseId}`);
-    return databaseId;
-  } catch (err) {
-    console.warn(
-      `Warning: Could not derive databaseId from wrangler.jsonc: ${err}`
-    );
-  }
-};
-const getPgCredentials = (serviceName) => {
-  if (isRemoteEnvironment()) {
-    return {
-      dbCredentials: {
-        url: process.env.DATABASE_URL
-      }
-    };
-  } else {
-    const databaseId = serviceName ? `${serviceName}-db` : getPgDatabaseIdFromWrangler() ?? "";
-    return {
-      dbCredentials: {
-        url: getPgLocalConnectionString(databaseId)
-      }
-    };
-  }
-};
-const getDrizzlePgConfig = () => ({
-  schema: "./src/database/schema/",
-  out: "./src/database/migrations/",
-  dialect: "postgresql",
-  ...getPgCredentials(),
-  migrations: {
-    table: "__drizzle_migrations",
-    schema: "public"
-  }
-});
-
-const calculateExponentialBackoff = (attempts, baseDelaySeconds) => {
-  return baseDelaySeconds ** attempts;
-};
-
-const service = (serviceName) => {
-  return function(constructor) {
-    return class extends constructor {
-      name = `${serviceName}-service`;
-    };
-  };
-};
-
-const action = (name) => {
-  return (_target, _propertyKey, descriptor) => {
-    const originalMethod = descriptor.value;
-    descriptor.value = function(...args) {
-      this.action = name;
-      return originalMethod.apply(this, args);
-    };
-    return descriptor;
-  };
-};
-
-function cloudflareQueue(options) {
-  return (_target, _propertyKey, descriptor) => {
-    const originalMethod = descriptor.value;
-    descriptor.value = async function(...args) {
-      const batch = args[0];
-      let retriedCount = 0;
-      batch.messages.forEach((msg) => {
-        const originalRetry = msg.retry?.bind(msg);
-        msg.retry = () => {
-          retriedCount++;
-          return originalRetry({
-            delaySeconds: calculateExponentialBackoff(
-              msg.attempts,
-              options.baseDelay
-            )
-          });
-        };
-      });
-      const result = await originalMethod.apply(this, args);
-      if (typeof this.logQueueRetries === "function") {
-        this.logQueueRetries({
-          message: `Retried ${retriedCount} out of ${batch.messages.length} messages`
-        });
-      }
-      return result;
-    };
-  };
-}
-
-function develitWorker(Worker) {
-  class DevelitWorker extends Worker {
-    name = "not-set";
-    action = "not-set";
-    // public db!: DatabaseTransaction<string>
-    async fetch() {
-      return new Response("Service is up and running!");
-    }
-    // initializeDB<TAuditAction = string>(
-    //   database: D1Database,
-    //   schema: Record<string, unknown>,
-    //   auditLogWriter?: AuditLogWriter<TAuditAction>,
-    // ): void {
-    //   const drizzleInstance = drizzle(database, {
-    //     schema,
-    //   }) as DrizzleD1Database<Record<string, unknown>>
-    //   this.db = new DatabaseTransaction<TAuditAction>(
-    //     drizzleInstance,
-    //     this.name,
-    //     auditLogWriter,
-    //   ) as unknown as DatabaseTransaction<string>
-    // }
-    handleInput({
-      input,
-      schema
-    }) {
-      this.logInput({ input });
-      const parseResult = z__namespace.safeParse(schema, input);
-      if (!parseResult.success) {
-        const parseError = {
-          status: 400,
-          code: "INVALID_ACTION_INPUT",
-          message: z__namespace.prettifyError(parseResult.error)
-        };
-        this.logError(parseError);
-        throw RPCResponse.validationError(parseError);
-      }
-      if (!parseResult.data) {
-        throw createInternalError({
-          message: "The provided input could not be processed."
-        });
-      }
-      return parseResult.data;
-    }
-    log(data, identifier) {
-      const name = identifier ?? `${this.name}:${this.action}:log`;
-      console.log(name, {
-        entrypoint: this.name,
-        action: this.action,
-        identifier: name,
-        data: superjson__default.stringify(data)
-      });
-    }
-    logQueuePush(data) {
-      this.log(data, `${this.name}:${this.action}:queue-push`);
-    }
-    logQueuePull(data) {
-      this.log(data, `${this.name}:${this.action}:queue-pull`);
-    }
-    logQueueRetries(data) {
-      this.log(data, `${this.name}:${this.action}:queue-retries`);
-    }
-    logInput(data) {
-      this.log(data, `${this.name}:${this.action}:input`);
-    }
-    logOutput(data) {
-      this.log(data, `${this.name}:${this.action}:output`);
-    }
-    logError(error) {
-      this.log(error, `${this.name}:${this.action}:error`);
-    }
-    pushToQueue(queue, message) {
-      if (!Array.isArray(message))
-        return queue.send(message, { contentType: "v8" });
-      return queue.sendBatch(
-        message.map((m) => ({
-          body: m,
-          contentType: "v8"
-        }))
-      );
-    }
-    recordAuditLogMessage(queue, message) {
-      const msg = { service: this.name, ...message, createdAt: /* @__PURE__ */ new Date() };
-      return this.pushToQueue(queue, msg);
-    }
-    async handleAction(input, options = {}, actionExecution) {
-      return handleAction(this, input, options, actionExecution);
-    }
-  }
-  return DevelitWorker;
-}
-
-exports.ENVIRONMENT = environment_consts.ENVIRONMENT;
-exports.DatabaseTransaction = DatabaseTransaction;
-exports.RPCResponse = RPCResponse;
-exports.action = action;
-exports.bankAccount = bankAccount;
-exports.bankAccountBankCodeEnum = bankAccountBankCodeEnum;
-exports.bankAccountCountryCodeEnum = bankAccountCountryCodeEnum;
-exports.bankAccountCurrencyEnum = bankAccountCurrencyEnum;
-exports.bankAccountPostgres = bankAccountPostgres;
-exports.base = base;
-exports.basePostgres = basePostgres;
-exports.calculateExponentialBackoff = calculateExponentialBackoff;
-exports.cloudflareQueue = cloudflareQueue;
-exports.createAuditLogWriter = createAuditLogWriter;
-exports.createInternalError = createInternalError;
-exports.defineCommand = defineCommand;
-exports.derivePortFromId = derivePortFromId;
-exports.develitWorker = develitWorker;
-exports.durableObjectNamespaceIdFromName = durableObjectNamespaceIdFromName;
-exports.first = first;
-exports.firstOrError = firstOrError;
-exports.getD1Credentials = getD1Credentials;
-exports.getD1DatabaseIdFromWrangler = getD1DatabaseIdFromWrangler;
-exports.getDrizzleD1Config = getDrizzleD1Config;
-exports.getDrizzlePgConfig = getDrizzlePgConfig;
-exports.getPgCredentials = getPgCredentials;
-exports.getPgDatabaseIdFromWrangler = getPgDatabaseIdFromWrangler;
-exports.getPgLocalConnectionString = getPgLocalConnectionString;
-exports.handleAction = handleAction;
-exports.handleActionResponse = handleActionResponse;
-exports.ibanZodSchema = ibanZodSchema;
-exports.isInternalError = isInternalError;
-exports.paginationQuerySchema = paginationQuerySchema;
-exports.paginationSchema = paginationSchema;
-exports.service = service;
-exports.swiftZodSchema = swiftZodSchema;
-exports.useFetch = useFetch;
-exports.useResult = useResult;
-exports.useResultSync = useResultSync;
-exports.uuidv4 = uuidv4;