@develit-io/backend-sdk 5.4.5

package/dist/index.mjs

@@ -0,0 +1,423 @@
+import { sql } from 'drizzle-orm';
+import { timestamp, uuid } from 'drizzle-orm/pg-core';
+import { integer, text } from 'drizzle-orm/sqlite-core';
+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 superjson from 'superjson';
+
+const base = {
+  id: text("id").primaryKey(),
+  createdAt: integer("created_at", { mode: "timestamp_ms" }).default(
+    sql`(unixepoch('subsec') * 1000)`
+  ),
+  modifiedAt: integer("modified_at", { mode: "timestamp_ms" }).default(sql`null`).$onUpdate(() => /* @__PURE__ */ new Date())
+};
+const basePostgres = {
+  id: uuid("id").primaryKey(),
+  createdAt: timestamp("created_at", { mode: "date", withTimezone: false }).defaultNow().notNull(),
+  modifiedAt: timestamp("modified_at", { mode: "date", withTimezone: false }).default(sql`null`).$onUpdate(() => /* @__PURE__ */ new Date())
+};
+
+const ibanZodSchema = new z.$ZodString({
+  type: "string",
+  checks: [
+    new z.$ZodCheckMinLength({
+      check: "min_length",
+      minimum: 1
+    }),
+    new z.$ZodCheckRegex({
+      check: "string_format",
+      format: "regex",
+      pattern: /^([A-Z]{2}[0-9]{2})([A-Z0-9]{4})([A-Z0-9]{4})([A-Z0-9]{4})([A-Z0-9]{4})?$/
+    })
+  ]
+});
+const swiftZodSchema = new z.$ZodString({
+  type: "string",
+  checks: [
+    new z.$ZodCheckMinLength({
+      check: "min_length",
+      minimum: 1
+    }),
+    new z.$ZodCheckRegex({
+      check: "string_format",
+      format: "regex",
+      pattern: /^[A-Z]{6}[A-Z0-9]{2}([A-Z0-9]{3})?$/
+    })
+  ]
+});
+
+const handleActionResponse = ({
+  error,
+  status,
+  message,
+  data
+}) => {
+  if (error) {
+    throw createError({ status, message });
+  }
+  if (data === void 0 || data === null) {
+    throw 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) {
+    consola.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(
+      actionExecution(validatedInput)
+    );
+    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 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 uuidv4 = () => crypto.randomUUID();
+
+const calculateExponentialBackoff = (attempts, baseDelaySeconds) => {
+  return baseDelaySeconds ** attempts;
+};
+
+const asNonEmpty = (arr) => {
+  return arr.length > 0 ? [arr[0], ...arr.slice(1)] : null;
+};
+
+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)
+  });
+};
+
+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 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.safeParse(schema, input);
+      if (!parseResult.success) {
+        const parseError = {
+          status: 400,
+          code: "INVALID_ACTION_INPUT",
+          message: z.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.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"
+        }))
+      );
+    }
+    async handleAction(input, options = {}, actionExecution) {
+      return handleAction(this, input, options, actionExecution);
+    }
+  }
+  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 };

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@develit-io/backend-sdk",
+  "version": "5.4.5",
+  "description": "Develit Backend SDK",
+  "author": "Develit.io",
+  "license": "ISC",
+  "type": "module",
+  "scripts": {
+    "prepack": "unbuild",
+    "typecheck": "tsc",
+    "lint": "biome check",
+    "lint:fix": "biome check --fix",
+    "build": "unbuild",
+    "changelogen": "bunx changelogen@latest --bump",
+    "release": "bun run build && bunx changelogen@latest --release --push && npm publish --access public"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.ts",
+  "files": ["dist"],
+  "dependencies": {
+    "@cloudflare/workers-types": "^4.20250407.0",
+    "consola": "^3.4.2",
+    "drizzle-kit": "^0.30.6",
+    "drizzle-orm": "^0.44.3",
+    "h3": "^1.15.3",
+    "http-status-codes": "2.3.0",
+    "superjson": "^2.2.2"
+  },
+  "peerDependencies": {
+    "zod": "^4.0.5"
+  }
+}