@guren/server 1.0.0-rc.9 → 1.0.0

package/dist/chunk-QQKTH5KX.js

@@ -0,0 +1,114 @@
+// src/encryption/Hash.ts
+import {
+  createHash,
+  createHmac,
+  randomBytes,
+  scrypt,
+  timingSafeEqual
+} from "crypto";
+import { promisify } from "util";
+var scryptAsync = promisify(scrypt);
+function hash(value, algorithm = "sha256", encoding = "hex") {
+  return createHash(algorithm).update(value).digest(encoding);
+}
+function hmac(value, key, options = {}) {
+  const { algorithm = "sha256", encoding = "hex" } = options;
+  return createHmac(algorithm, key).update(value).digest(encoding);
+}
+function verifyHmac(value, signature, key, options = {}) {
+  const expected = hmac(value, key, options);
+  return secureCompare(signature, expected);
+}
+function sha256(value) {
+  return hash(value, "sha256");
+}
+function sha512(value) {
+  return hash(value, "sha512");
+}
+function md5(value) {
+  return hash(value, "md5");
+}
+async function hashPassword(password, options = {}) {
+  const {
+    cost = 16384,
+    // N
+    memory = 8,
+    // r (block size)
+    saltLength = 16,
+    keyLength = 64
+  } = options;
+  const salt = randomBytes(saltLength);
+  const derived = await scryptAsync(password, salt, keyLength, {
+    N: cost,
+    r: memory,
+    p: 1
+  });
+  const params = `N=${cost},r=${memory},p=1`;
+  return `$scrypt$${params}$${salt.toString("base64")}$${derived.toString("base64")}`;
+}
+async function verifyPassword(password, hash2) {
+  if (!hash2.startsWith("$scrypt$")) {
+    throw new Error("Invalid password hash format.");
+  }
+  const parts = hash2.split("$");
+  if (parts.length !== 5) {
+    throw new Error("Invalid password hash format.");
+  }
+  const [, , paramsStr, saltB64, hashB64] = parts;
+  const params = {};
+  for (const param of paramsStr.split(",")) {
+    const [key, value] = param.split("=");
+    params[key] = parseInt(value, 10);
+  }
+  const salt = Buffer.from(saltB64, "base64");
+  const expectedHash = Buffer.from(hashB64, "base64");
+  const derived = await scryptAsync(password, salt, expectedHash.length, {
+    N: params.N,
+    r: params.r,
+    p: params.p ?? 1
+  });
+  return timingSafeEqual(derived, expectedHash);
+}
+function needsRehash(hash2, options = {}) {
+  const { cost = 16384, memory = 8 } = options;
+  if (!hash2.startsWith("$scrypt$")) {
+    return true;
+  }
+  const parts = hash2.split("$");
+  if (parts.length !== 5) {
+    return true;
+  }
+  const paramsStr = parts[2];
+  const params = {};
+  for (const param of paramsStr.split(",")) {
+    const [key, value] = param.split("=");
+    params[key] = parseInt(value, 10);
+  }
+  return params.N !== cost || params.r !== memory;
+}
+function secureCompare(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  const bufA = Buffer.from(a);
+  const bufB = Buffer.from(b);
+  return timingSafeEqual(bufA, bufB);
+}
+function check(value, hash2, algorithm = "sha256") {
+  const computed = createHash(algorithm).update(value).digest("hex");
+  return secureCompare(computed, hash2);
+}
+
+export {
+  hash,
+  hmac,
+  verifyHmac,
+  sha256,
+  sha512,
+  md5,
+  hashPassword,
+  verifyPassword,
+  needsRehash,
+  secureCompare,
+  check
+};

package/dist/chunk-R2TCP7D7.js

@@ -0,0 +1,409 @@
+// src/container/Container.ts
+var Container = class _Container {
+  bindings = /* @__PURE__ */ new Map();
+  aliases = /* @__PURE__ */ new Map();
+  tags = /* @__PURE__ */ new Map();
+  contextualBindings = [];
+  resolvingStack = [];
+  scopedInstances = [];
+  fakes = /* @__PURE__ */ new Map();
+  /** @internal Used by ProviderManager to resolve deferred providers on demand */
+  deferredProviderLoader = null;
+  /**
+   * Bind a service to the container.
+   * Each resolution creates a new instance.
+   */
+  bind(key, factory) {
+    this.bindings.set(key, {
+      factory,
+      singleton: false
+    });
+    return this;
+  }
+  /**
+   * Bind a singleton service to the container.
+   * Only one instance is created and reused.
+   */
+  singleton(key, factory) {
+    this.bindings.set(key, {
+      factory,
+      singleton: true
+    });
+    return this;
+  }
+  /**
+   * Bind an existing instance to the container.
+   */
+  instance(key, value) {
+    this.bindings.set(key, {
+      factory: () => value,
+      singleton: true,
+      instance: value
+    });
+    return this;
+  }
+  make(key) {
+    if (this.fakes.has(key)) {
+      return this.fakes.get(key);
+    }
+    const resolvedKey = this.resolveAlias(key);
+    if (resolvedKey !== key && this.fakes.has(resolvedKey)) {
+      return this.fakes.get(resolvedKey);
+    }
+    let binding = this.bindings.get(resolvedKey);
+    if (!binding && this.deferredProviderLoader) {
+      let resolved = false;
+      this.deferredProviderLoader(resolvedKey).then(() => {
+        resolved = true;
+      });
+      if (resolved) {
+        binding = this.bindings.get(resolvedKey);
+      }
+    }
+    if (!binding) {
+      throw new Error(`Service "${key}" not found in container`);
+    }
+    if (binding.singleton && binding.instance !== void 0) {
+      return binding.instance;
+    }
+    if (this.scopedInstances.length > 0) {
+      const currentScope = this.scopedInstances[this.scopedInstances.length - 1];
+      if (currentScope.has(resolvedKey)) {
+        return currentScope.get(resolvedKey);
+      }
+    }
+    const contextualFactory = this.findContextualBinding(resolvedKey);
+    this.resolvingStack.push(resolvedKey);
+    try {
+      const factory = contextualFactory ?? binding.factory;
+      const instance = factory(this);
+      if (binding.singleton) {
+        binding.instance = instance;
+      }
+      if (this.scopedInstances.length > 0 && !binding.singleton) {
+        const currentScope = this.scopedInstances[this.scopedInstances.length - 1];
+        currentScope.set(resolvedKey, instance);
+      }
+      return instance;
+    } finally {
+      this.resolvingStack.pop();
+    }
+  }
+  /**
+   * Resolve a service with additional parameters.
+   */
+  makeWith(key, params) {
+    const resolvedKey = this.resolveAlias(key);
+    const binding = this.bindings.get(resolvedKey);
+    if (!binding) {
+      throw new Error(`Service "${key}" not found in container`);
+    }
+    const tempContainer = new _Container();
+    for (const [k, v] of this.bindings) {
+      tempContainer.bindings.set(k, { ...v });
+    }
+    for (const [paramKey, paramValue] of Object.entries(params)) {
+      tempContainer.instance(paramKey, paramValue);
+    }
+    return binding.factory(tempContainer);
+  }
+  /**
+   * Check if a service is bound in the container.
+   */
+  has(key) {
+    const resolvedKey = this.resolveAlias(key);
+    return this.bindings.has(resolvedKey);
+  }
+  /**
+   * Create an alias for a service.
+   */
+  alias(alias, key) {
+    if (alias === key) {
+      throw new Error("Alias cannot be the same as the key");
+    }
+    this.aliases.set(alias, key);
+    return this;
+  }
+  /**
+   * Tag multiple services with a tag name.
+   */
+  tag(keys, tagName) {
+    let taggedKeys = this.tags.get(tagName);
+    if (!taggedKeys) {
+      taggedKeys = /* @__PURE__ */ new Set();
+      this.tags.set(tagName, taggedKeys);
+    }
+    for (const key of keys) {
+      taggedKeys.add(key);
+    }
+    return this;
+  }
+  /**
+   * Resolve all services with a given tag.
+   */
+  tagged(tagName) {
+    const taggedKeys = this.tags.get(tagName);
+    if (!taggedKeys) {
+      return [];
+    }
+    return Array.from(taggedKeys).map((key) => this.make(key));
+  }
+  /**
+   * Define a contextual binding.
+   */
+  when(concrete) {
+    return {
+      needs: (abstract) => {
+        return {
+          give: (factoryOrValue) => {
+            const factory = typeof factoryOrValue === "function" ? factoryOrValue : () => factoryOrValue;
+            this.contextualBindings.push({
+              concrete,
+              needs: abstract,
+              factory
+            });
+          }
+        };
+      }
+    };
+  }
+  /**
+   * Run a callback within a scoped context.
+   * Services resolved within the scope are cached and released when the scope ends.
+   */
+  scoped(callback) {
+    this.scopedInstances.push(/* @__PURE__ */ new Map());
+    try {
+      return callback();
+    } finally {
+      this.scopedInstances.pop();
+    }
+  }
+  /**
+   * Run an async callback within a scoped context.
+   */
+  async scopedAsync(callback) {
+    this.scopedInstances.push(/* @__PURE__ */ new Map());
+    try {
+      return await callback();
+    } finally {
+      this.scopedInstances.pop();
+    }
+  }
+  fake(key, instance) {
+    this.fakes.set(key, instance);
+    return {
+      [Symbol.dispose]: () => {
+        this.fakes.delete(key);
+      }
+    };
+  }
+  /**
+   * Check if a service is currently faked.
+   */
+  isFaked(key) {
+    return this.fakes.has(key);
+  }
+  /**
+   * Remove all fakes.
+   */
+  clearFakes() {
+    this.fakes.clear();
+  }
+  /**
+   * Flush all resolved singleton instances.
+   */
+  flush() {
+    for (const binding of this.bindings.values()) {
+      binding.instance = void 0;
+    }
+  }
+  /**
+   * Remove a binding from the container.
+   */
+  forget(key) {
+    const resolvedKey = this.resolveAlias(key);
+    this.bindings.delete(resolvedKey);
+    return this;
+  }
+  /**
+   * Get all bound service keys.
+   */
+  getBindings() {
+    return Array.from(this.bindings.keys());
+  }
+  /**
+   * Get all aliases.
+   */
+  getAliases() {
+    const result = {};
+    for (const [alias, key] of this.aliases) {
+      result[alias] = key;
+    }
+    return result;
+  }
+  /**
+   * Get all tags.
+   */
+  getTags() {
+    const result = {};
+    for (const [tag, keys] of this.tags) {
+      result[tag] = Array.from(keys);
+    }
+    return result;
+  }
+  resolveAlias(key) {
+    let resolved = key;
+    const seen = /* @__PURE__ */ new Set();
+    while (this.aliases.has(resolved)) {
+      if (seen.has(resolved)) {
+        throw new Error(`Circular alias detected: ${key}`);
+      }
+      seen.add(resolved);
+      resolved = this.aliases.get(resolved);
+    }
+    return resolved;
+  }
+  findContextualBinding(needs) {
+    if (this.resolvingStack.length === 0) {
+      return null;
+    }
+    const currentConcrete = this.resolvingStack[this.resolvingStack.length - 1];
+    for (const binding of this.contextualBindings) {
+      if (binding.concrete === currentConcrete && binding.needs === needs) {
+        return binding.factory;
+      }
+    }
+    return null;
+  }
+};
+function createContainer() {
+  return new Container();
+}
+var globalContainer = null;
+function setContainer(container) {
+  globalContainer = container;
+}
+function getContainer() {
+  if (!globalContainer) {
+    throw new Error("Container not initialized. Call setContainer() first.");
+  }
+  return globalContainer;
+}
+function resolve(key) {
+  return getContainer().make(key);
+}
+
+// src/queue/Job.ts
+import { randomBytes } from "crypto";
+var globalDriver = null;
+function setQueueDriver(driver) {
+  globalDriver = driver;
+}
+function getQueueDriver() {
+  return globalDriver;
+}
+function generateJobId() {
+  return randomBytes(16).toString("hex");
+}
+var Job = class {
+  /**
+   * The queue this job should be dispatched to.
+   * @default 'default'
+   */
+  static queue = "default";
+  /**
+   * Maximum number of times the job should be attempted.
+   * @default 3
+   */
+  static maxAttempts = 3;
+  /**
+   * Backoff strategy for retries.
+   * - 'exponential': 2^attempt * 1000ms (1s, 2s, 4s, 8s, ...)
+   * - 'linear': attempt * 1000ms (1s, 2s, 3s, 4s, ...)
+   * - number: fixed delay in milliseconds
+   * @default 'exponential'
+   */
+  static backoff = "exponential";
+  make(key) {
+    return getContainer().make(key);
+  }
+  /**
+   * Dispatch the job to the queue.
+   *
+   * @param payload - Job payload data
+   * @param options - Optional dispatch options
+   */
+  static async dispatch(payload, options = {}) {
+    const driver = globalDriver;
+    if (!driver) {
+      throw new Error("Queue driver not configured. Call setQueueDriver() first.");
+    }
+    const jobId = generateJobId();
+    const now = /* @__PURE__ */ new Date();
+    const delay = options.delay ?? 0;
+    const job = {
+      id: jobId,
+      name: this.name,
+      payload,
+      queue: options.queue ?? this.queue,
+      attempts: 0,
+      maxAttempts: options.maxAttempts ?? this.maxAttempts,
+      availableAt: new Date(now.getTime() + delay),
+      createdAt: now,
+      reservedAt: null
+    };
+    await driver.push(job);
+    return jobId;
+  }
+  /**
+   * Dispatch the job after a delay.
+   *
+   * @param delayMs - Delay in milliseconds
+   * @param payload - Job payload data
+   * @param options - Optional dispatch options (delay is overridden)
+   */
+  static async dispatchAfter(delayMs, payload, options = {}) {
+    return this.dispatch(payload, { ...options, delay: delayMs });
+  }
+  /**
+   * Calculate the retry delay based on backoff strategy.
+   */
+  static calculateRetryDelay(attempts) {
+    if (typeof this.backoff === "number") {
+      return this.backoff;
+    }
+    if (this.backoff === "linear") {
+      return attempts * 1e3;
+    }
+    return Math.pow(2, attempts) * 1e3;
+  }
+};
+var jobRegistry = /* @__PURE__ */ new Map();
+function registerJob(jobClass) {
+  jobRegistry.set(jobClass.name, jobClass);
+}
+function getJob(name) {
+  return jobRegistry.get(name);
+}
+function getRegisteredJobs() {
+  return new Map(jobRegistry);
+}
+function clearJobRegistry() {
+  jobRegistry.clear();
+}
+
+export {
+  Container,
+  createContainer,
+  setContainer,
+  getContainer,
+  resolve,
+  setQueueDriver,
+  getQueueDriver,
+  Job,
+  registerJob,
+  getJob,
+  getRegisteredJobs,
+  clearJobRegistry
+};