@kabyeon/nexusjs 0.6.5

package/dist/redis/index.js

@@ -0,0 +1,667 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/core/constants.ts
+var METADATA_KEY, PARAM_TYPES, HTTP_METHODS;
+var init_constants = __esm(() => {
+  METADATA_KEY = {
+    CONTROLLER: "nexus:controller",
+    INJECTABLE: "nexus:injectable",
+    REPOSITORY: "nexus:repository",
+    MODULE: "nexus:module",
+    ROUTES: "nexus:routes",
+    PARAMS: "nexus:params",
+    VALIDATE: "nexus:validate",
+    PARAMTYPES: "design:paramtypes",
+    TYPE: "design:type",
+    RETURNTYPE: "design:returntype",
+    INJECT: "nexus:inject"
+  };
+  PARAM_TYPES = {
+    REQUEST: 0,
+    RESPONSE: 1,
+    NEXT: 2,
+    BODY: 3,
+    QUERY: 4,
+    PARAM: 5,
+    HEADERS: 6,
+    CTX: 7,
+    USER: 8
+  };
+  HTTP_METHODS = [
+    "GET",
+    "POST",
+    "PUT",
+    "DELETE",
+    "PATCH",
+    "OPTIONS",
+    "HEAD"
+  ];
+});
+
+// src/core/decorators/controller.ts
+import"reflect-metadata";
+function Controller(prefix = "/") {
+  return (target) => {
+    const normalized = normalizePrefix(prefix);
+    const meta = { prefix: normalized };
+    Reflect.defineMetadata(METADATA_KEY.CONTROLLER, meta, target);
+  };
+}
+function getControllerMetadata(target) {
+  return Reflect.getMetadata(METADATA_KEY.CONTROLLER, target) ?? { prefix: "/" };
+}
+function isController(target) {
+  return Reflect.hasMetadata(METADATA_KEY.CONTROLLER, target);
+}
+function normalizePrefix(prefix) {
+  if (!prefix)
+    return "";
+  if (prefix !== "/" && prefix.endsWith("/")) {
+    return prefix.slice(0, -1);
+  }
+  return prefix;
+}
+var init_controller = __esm(() => {
+  init_constants();
+});
+
+// src/core/decorators/http-methods.ts
+import"reflect-metadata";
+function defineRoute(method, path) {
+  return (target, propertyKey, descriptor) => {
+    const routes = Reflect.getMetadata(METADATA_KEY.ROUTES, target.constructor) ?? [];
+    routes.push({
+      method,
+      path: normalizePath(path),
+      propertyKey,
+      handler: descriptor.value
+    });
+    Reflect.defineMetadata(METADATA_KEY.ROUTES, routes, target.constructor);
+  };
+}
+function normalizePath(path) {
+  if (!path || path === "/")
+    return "/";
+  return path.startsWith("/") ? path : `/${path}`;
+}
+function getRoutes(target) {
+  return Reflect.getMetadata(METADATA_KEY.ROUTES, target) ?? [];
+}
+var Get = (path = "/") => defineRoute("GET", path), Post = (path = "/") => defineRoute("POST", path), Put = (path = "/") => defineRoute("PUT", path), Delete = (path = "/") => defineRoute("DELETE", path), Patch = (path = "/") => defineRoute("PATCH", path), Options = (path = "/") => defineRoute("OPTIONS", path), Head = (path = "/") => defineRoute("HEAD", path);
+var init_http_methods = __esm(() => {
+  init_constants();
+});
+
+// src/core/decorators/params.ts
+import"reflect-metadata";
+function createParamDecorator(type, data) {
+  return (target, propertyKey, parameterIndex) => {
+    if (propertyKey !== undefined) {
+      const params = Reflect.getMetadata(METADATA_KEY.PARAMS, target, propertyKey) ?? [];
+      params.push({
+        index: parameterIndex,
+        type,
+        name: typeof data === "string" ? data : undefined,
+        data: typeof data === "object" ? data : undefined
+      });
+      Reflect.defineMetadata(METADATA_KEY.PARAMS, params, target, propertyKey);
+    } else {
+      const params = Reflect.getMetadata(METADATA_KEY.PARAMS, target) ?? [];
+      params.push({
+        index: parameterIndex,
+        type,
+        name: typeof data === "string" ? data : undefined,
+        data: typeof data === "object" ? data : undefined
+      });
+      Reflect.defineMetadata(METADATA_KEY.PARAMS, params, target);
+    }
+  };
+}
+function getParamMetadata(target, propertyKey) {
+  return Reflect.getMetadata(METADATA_KEY.PARAMS, target, propertyKey) ?? [];
+}
+var Req = () => createParamDecorator(PARAM_TYPES.REQUEST), Res = () => createParamDecorator(PARAM_TYPES.RESPONSE), Next = () => createParamDecorator(PARAM_TYPES.NEXT), Body = (key) => createParamDecorator(PARAM_TYPES.BODY, key), Query = (key) => createParamDecorator(PARAM_TYPES.QUERY, key), Param = (key) => createParamDecorator(PARAM_TYPES.PARAM, key), Headers = (key) => createParamDecorator(PARAM_TYPES.HEADERS, key), Ctx = () => createParamDecorator(PARAM_TYPES.CTX), User = () => createParamDecorator(PARAM_TYPES.USER);
+var init_params = __esm(() => {
+  init_constants();
+});
+
+// src/core/decorators/validate.ts
+import"reflect-metadata";
+function Validate(options) {
+  return (target, propertyKey, descriptor) => {
+    Reflect.defineMetadata(METADATA_KEY.VALIDATE, options, target.constructor, propertyKey);
+  };
+}
+function getValidationMetadata(target, propertyKey) {
+  return Reflect.getMetadata(METADATA_KEY.VALIDATE, target, propertyKey);
+}
+var init_validate = __esm(() => {
+  init_constants();
+});
+
+// src/redis/adapters/bun.ts
+class BunRedisAdapter {
+  adapter = "bun";
+  client = null;
+  url;
+  keyPrefix;
+  defaultTtlSeconds;
+  constructor(config = {}) {
+    this.url = config.url ?? process.env["REDIS_URL"] ?? "redis://localhost:6379";
+    this.keyPrefix = config.keyPrefix ?? "";
+    this.defaultTtlSeconds = config.defaultTtlSeconds ?? 0;
+  }
+  getClient() {
+    if (this.client)
+      return this.client;
+    const bun = globalThis.Bun;
+    if (!bun || typeof bun.redis !== "function") {
+      throw new Error("BunRedisAdapter can only be used in a Bun runtime. " + "On Node, use NodeRedisAdapter (install ioredis).");
+    }
+    this.client = bun.redis(this.url);
+    return this.client;
+  }
+  k(key) {
+    return this.keyPrefix + key;
+  }
+  async get(key) {
+    return this.getClient().get(this.k(key));
+  }
+  async set(key, value, options) {
+    const ex = options?.ex ?? this.defaultTtlSeconds ?? undefined;
+    const px = options?.px ?? undefined;
+    const bunOpts = {};
+    if (ex)
+      bunOpts.EX = ex;
+    if (px)
+      bunOpts.PX = px;
+    if (options?.nx)
+      bunOpts.NX = true;
+    if (options?.xx)
+      bunOpts.XX = true;
+    await this.getClient().set(this.k(key), value, bunOpts);
+  }
+  async del(key) {
+    return this.getClient().del(this.k(key));
+  }
+  async exists(key) {
+    return await this.getClient().exists(this.k(key)) > 0;
+  }
+  async incr(key, by = 1, options) {
+    const fullKey = this.k(key);
+    const client = this.getClient();
+    const value = await client.incr(fullKey);
+    if (options?.ex && value === by) {
+      await client.set(fullKey, String(value), { EX: options.ex });
+    }
+    return value;
+  }
+  async scan(options = {}) {
+    const cursor = typeof options.cursor === "number" ? options.cursor : 0;
+    const res = await this.getClient().scan(cursor, {
+      MATCH: options.match ?? "*",
+      COUNT: options.count ?? 100
+    });
+    return {
+      cursor: res.cursor,
+      keys: (res.keys ?? []).map((k) => this.keyPrefix && k.startsWith(this.keyPrefix) ? k.slice(this.keyPrefix.length) : k)
+    };
+  }
+  async close() {
+    if (this.client) {
+      await this.client.close();
+      this.client = null;
+    }
+  }
+}
+
+// src/redis/adapters/cloudflare.ts
+class CloudflareKVAdapter {
+  adapter = "cloudflare";
+  kv = null;
+  keyPrefix;
+  defaultTtlSeconds;
+  constructor(config = {}) {
+    this.keyPrefix = config.keyPrefix ?? "";
+    this.defaultTtlSeconds = config.defaultTtlSeconds ?? 0;
+    if (config.kv)
+      this.kv = config.kv;
+  }
+  getKV() {
+    if (this.kv)
+      return this.kv;
+    const env = globalThis.env;
+    if (env?.KV) {
+      this.kv = env.KV;
+      return this.kv;
+    }
+    throw new Error("CloudflareKVAdapter could not find a KV binding. " + "Pass it explicitly via RedisConfig({ kv }) or run inside a " + "Workers request handler where `c.env.KV` is available.");
+  }
+  k(key) {
+    return this.keyPrefix + key;
+  }
+  stripPrefix(key) {
+    return this.keyPrefix && key.startsWith(this.keyPrefix) ? key.slice(this.keyPrefix.length) : key;
+  }
+  async get(key) {
+    return this.getKV().get(this.k(key));
+  }
+  async set(key, value, options) {
+    const ex = options?.ex ?? this.defaultTtlSeconds ?? undefined;
+    if (ex && ex > 0) {
+      await this.getKV().put(this.k(key), value, { expirationTtl: ex });
+    } else {
+      await this.getKV().put(this.k(key), value);
+    }
+  }
+  async del(key) {
+    const existed = await this.getKV().get(this.k(key)) !== null;
+    await this.getKV().delete(this.k(key));
+    return existed ? 1 : 0;
+  }
+  async exists(key) {
+    return await this.getKV().get(this.k(key)) !== null;
+  }
+  async incr(key, by = 1, options) {
+    const fullKey = this.k(key);
+    const raw = await this.getKV().get(fullKey);
+    const current = raw ? Number.parseInt(raw, 10) || 0 : 0;
+    const next = current + by;
+    const ex = options?.ex ?? this.defaultTtlSeconds ?? undefined;
+    if (ex && ex > 0) {
+      await this.getKV().put(fullKey, String(next), { expirationTtl: ex });
+    } else {
+      await this.getKV().put(fullKey, String(next));
+    }
+    return next;
+  }
+  async scan(options = {}) {
+    const match = options.match ?? "*";
+    const prefix = globToPrefix(match, this.keyPrefix);
+    const res = await this.getKV().list({
+      prefix,
+      limit: options.count ?? 100,
+      cursor: typeof options.cursor === "string" ? options.cursor : undefined
+    });
+    return {
+      cursor: res.cursor,
+      keys: (res.keys ?? []).map((k) => this.stripPrefix(k.name))
+    };
+  }
+  async close() {}
+}
+function globToPrefix(glob, keyPrefix) {
+  const meta = /[*?\[]/.exec(glob);
+  const base = meta ? glob.slice(0, meta.index) : glob;
+  return (keyPrefix ?? "") + base;
+}
+
+// src/redis/adapters/memory.ts
+class MemoryRedisAdapter {
+  adapter = "memory";
+  data = new Map;
+  keyPrefix;
+  defaultTtlSeconds;
+  constructor(config = {}) {
+    this.keyPrefix = config.keyPrefix ?? "";
+    this.defaultTtlSeconds = config.defaultTtlSeconds ?? 0;
+  }
+  k(key) {
+    return this.keyPrefix + key;
+  }
+  stripPrefix(key) {
+    return this.keyPrefix && key.startsWith(this.keyPrefix) ? key.slice(this.keyPrefix.length) : key;
+  }
+  isExpired(e) {
+    return !e || e.expiresAt !== null && e.expiresAt < Date.now();
+  }
+  purge(key) {
+    const e = this.data.get(key);
+    if (this.isExpired(e))
+      this.data.delete(key);
+  }
+  async get(key) {
+    const k = this.k(key);
+    this.purge(k);
+    const e = this.data.get(k);
+    return e ? e.value : null;
+  }
+  async set(key, value, options) {
+    const k = this.k(key);
+    const ttl = options?.ex !== undefined ? options.ex : options?.px !== undefined ? options.px / 1000 : this.defaultTtlSeconds;
+    const expiresAt = ttl && ttl > 0 ? Date.now() + ttl * 1000 : null;
+    if (options?.nx && !this.isExpired(this.data.get(k)))
+      return;
+    if (options?.xx && this.isExpired(this.data.get(k)))
+      return;
+    this.data.set(k, { value, expiresAt });
+  }
+  async del(key) {
+    const k = this.k(key);
+    const existed = this.data.delete(k);
+    return existed ? 1 : 0;
+  }
+  async exists(key) {
+    const k = this.k(key);
+    this.purge(k);
+    return this.data.has(k);
+  }
+  async incr(key, by = 1, options) {
+    const k = this.k(key);
+    this.purge(k);
+    const e = this.data.get(k);
+    const current = e ? Number.parseInt(e.value, 10) || 0 : 0;
+    const next = current + by;
+    const ttl = options?.ex ?? this.defaultTtlSeconds ?? undefined;
+    const expiresAt = ttl && ttl > 0 ? Date.now() + ttl * 1000 : null;
+    this.data.set(k, { value: String(next), expiresAt });
+    return next;
+  }
+  async scan(options = {}) {
+    const match = options.match ?? "*";
+    const re = globToRegex(match);
+    const keys = [];
+    for (const k of this.data.keys()) {
+      if (this.keyPrefix && !k.startsWith(this.keyPrefix))
+        continue;
+      if (re.test(k))
+        keys.push(this.stripPrefix(k));
+    }
+    return { cursor: "0", keys };
+  }
+  async close() {
+    this.data.clear();
+  }
+}
+function globToRegex(glob) {
+  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  return new RegExp("^" + escaped + "$");
+}
+
+// src/redis/adapters/node.ts
+class NodeRedisAdapter {
+  adapter = "node";
+  client = null;
+  url;
+  keyPrefix;
+  defaultTtlSeconds;
+  nodeOptions;
+  constructor(config = {}) {
+    this.url = config.url ?? process.env["REDIS_URL"] ?? "redis://localhost:6379";
+    this.keyPrefix = config.keyPrefix ?? "";
+    this.defaultTtlSeconds = config.defaultTtlSeconds ?? 0;
+    this.nodeOptions = config.nodeOptions ?? {};
+  }
+  async getClient() {
+    if (this.client)
+      return this.client;
+    try {
+      const mod = await import("ioredis");
+      const Ctor = mod.default ?? mod;
+      if (typeof Ctor !== "function") {
+        throw new Error("ioredis module did not export a constructor");
+      }
+      this.client = new Ctor(this.url, this.nodeOptions);
+    } catch (err) {
+      throw new Error("NodeRedisAdapter requires the `ioredis` package. Install with: bun add ioredis");
+    }
+    return this.client;
+  }
+  k(key) {
+    return this.keyPrefix + key;
+  }
+  stripPrefix(key) {
+    return this.keyPrefix && key.startsWith(this.keyPrefix) ? key.slice(this.keyPrefix.length) : key;
+  }
+  async get(key) {
+    return (await this.getClient()).get(this.k(key));
+  }
+  async set(key, value, options) {
+    const ex = options?.ex ?? this.defaultTtlSeconds ?? undefined;
+    const c = await this.getClient();
+    const fullKey = this.k(key);
+    if (options?.nx) {
+      await c.set(fullKey, value, "EX", ex ?? 0, "NX");
+    } else if (options?.xx) {
+      await c.set(fullKey, value, "EX", ex ?? 0, "XX");
+    } else if (ex) {
+      await c.set(fullKey, value, "EX", ex);
+    } else {
+      await c.set(fullKey, value);
+    }
+  }
+  async del(key) {
+    return (await this.getClient()).del(this.k(key));
+  }
+  async exists(key) {
+    const n = await (await this.getClient()).exists(this.k(key));
+    return n > 0;
+  }
+  async incr(key, by = 1, options) {
+    const fullKey = this.k(key);
+    const c = await this.getClient();
+    let value;
+    if (by === 1) {
+      value = await c.incr(fullKey);
+    } else {
+      value = await c.incrby(fullKey, by);
+    }
+    if (options?.ex && value === by) {
+      await c.expire(fullKey, options.ex);
+    }
+    return value;
+  }
+  async scan(options = {}) {
+    const cursor = typeof options.cursor === "number" || typeof options.cursor === "string" ? options.cursor : 0;
+    const [next, keys] = await (await this.getClient()).scan(cursor, options.match ?? "*", options.count ?? 100);
+    return {
+      cursor: next,
+      keys: (keys ?? []).map((k) => this.stripPrefix(k))
+    };
+  }
+  async close() {
+    if (this.client) {
+      try {
+        await this.client.quit();
+      } catch {
+        this.client.disconnect();
+      }
+      this.client = null;
+    }
+  }
+}
+
+// src/redis/adapters/index.ts
+function detectRedisRuntime() {
+  if (typeof globalThis.caches !== "undefined" && typeof globalThis.WebSocketPair !== "undefined") {
+    return "cloudflare";
+  }
+  if (typeof globalThis.Bun !== "undefined")
+    return "bun";
+  if (typeof process !== "undefined" && process.versions?.node)
+    return "node";
+  return "memory";
+}
+function createRedisClient(config = {}) {
+  const adapter = config.adapter ?? detectRedisRuntime();
+  switch (adapter) {
+    case "bun":
+      return new BunRedisAdapter(config);
+    case "node":
+      return new NodeRedisAdapter(config);
+    case "cloudflare":
+      return new CloudflareKVAdapter(config);
+    case "memory":
+      return new MemoryRedisAdapter(config);
+    default: {
+      const _exhaustive = adapter;
+      throw new Error(`unknown redis adapter: ${_exhaustive}`);
+    }
+  }
+}
+// src/core/decorators/module.ts
+init_constants();
+import"reflect-metadata";
+function Module(options = {}) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEY.MODULE, options, target);
+  };
+}
+function getModuleOptions(target) {
+  return Reflect.getMetadata(METADATA_KEY.MODULE, target) ?? {};
+}
+
+// src/core/decorators/index.ts
+init_controller();
+
+// src/core/decorators/injectable.ts
+init_constants();
+import"reflect-metadata";
+function Injectable(options = {}) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEY.INJECTABLE, true, target);
+    if (options.scope) {
+      Reflect.defineMetadata("nexus:di:scope", options.scope, target);
+    }
+  };
+}
+function isInjectable(target) {
+  return Reflect.hasMetadata(METADATA_KEY.INJECTABLE, target);
+}
+function getScope(target) {
+  return Reflect.getMetadata("nexus:di:scope", target);
+}
+function Inject(token) {
+  return (target, propertyKey, parameterIndex) => {
+    const existing = Reflect.getMetadata(METADATA_KEY.INJECT, target) ?? new Map;
+    existing.set(parameterIndex, token);
+    Reflect.defineMetadata(METADATA_KEY.INJECT, existing, target);
+  };
+}
+
+// src/core/decorators/index.ts
+init_http_methods();
+init_params();
+init_validate();
+
+// src/core/decorators/repository.ts
+init_constants();
+import"reflect-metadata";
+function Repository(entityToken) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEY.REPOSITORY, { entity: entityToken }, target);
+    Reflect.defineMetadata(METADATA_KEY.INJECTABLE, true, target);
+  };
+}
+function getRepositoryMetadata(target) {
+  return Reflect.getMetadata(METADATA_KEY.REPOSITORY, target);
+}
+function isRepository(target) {
+  return Reflect.hasMetadata(METADATA_KEY.REPOSITORY, target);
+}
+// src/core/decorators/metadata.ts
+init_constants();
+// src/redis/module.ts
+var REDIS_CLIENT_TOKEN = Symbol.for("nexus:RedisClient");
+
+class RedisModule {
+  static forRoot(config = {}) {
+
+    class ConfiguredRedisModule {
+    }
+    ConfiguredRedisModule = __legacyDecorateClassTS([
+      Module({
+        providers: [
+          {
+            provide: REDIS_CLIENT_TOKEN,
+            useFactory: () => createRedisClient(config)
+          },
+          { provide: "REDIS_CONFIG", useValue: config }
+        ],
+        exports: [REDIS_CLIENT_TOKEN, "REDIS_CONFIG"]
+      })
+    ], ConfiguredRedisModule);
+    Object.defineProperty(ConfiguredRedisModule, "name", {
+      value: "ConfiguredRedisModule"
+    });
+    return ConfiguredRedisModule;
+  }
+}
+RedisModule = __legacyDecorateClassTS([
+  Module({
+    providers: [
+      {
+        provide: REDIS_CLIENT_TOKEN,
+        useFactory: () => createRedisClient()
+      }
+    ],
+    exports: [REDIS_CLIENT_TOKEN]
+  })
+], RedisModule);
+export {
+  detectRedisRuntime,
+  createRedisClient,
+  RedisModule,
+  REDIS_CLIENT_TOKEN,
+  NodeRedisAdapter,
+  MemoryRedisAdapter,
+  CloudflareKVAdapter,
+  BunRedisAdapter
+};
+
+//# debugId=1A5033ACD8F39BF864756E2164756E21
+//# sourceMappingURL=index.js.map