@kabyeon/nexusjs 0.6.5

package/dist/drive/index.js

@@ -0,0 +1,714 @@
+// @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/drive/types.ts
+import"reflect-metadata";
+// src/drive/drivers/memory.ts
+class MemoryDriver {
+  kind = "memory";
+  data = new Map;
+  async put(key, body, opts = {}) {
+    const buf = toBuffer(body);
+    const contentType = opts.contentType ?? "application/octet-stream";
+    this.data.set(key, {
+      body: buf,
+      meta: {
+        key,
+        size: buf.length,
+        contentType,
+        lastModified: Date.now(),
+        etag: simpleEtag(buf),
+        metadata: opts.metadata
+      }
+    });
+  }
+  async get(key) {
+    const e = this.data.get(key);
+    if (!e)
+      throw new Error(`File not found: ${key}`);
+    return e.body;
+  }
+  async delete(key) {
+    return this.data.delete(key);
+  }
+  async exists(key) {
+    return this.data.has(key);
+  }
+  async head(key) {
+    const e = this.data.get(key);
+    if (!e)
+      throw new Error(`File not found: ${key}`);
+    return { ...e.meta };
+  }
+  async list(opts = {}) {
+    const all = [...this.data.keys()].sort();
+    const prefix = opts.prefix ?? "";
+    const filtered = prefix ? all.filter((k) => k.startsWith(prefix)) : all;
+    const limit = opts.limit ?? 1000;
+    const startIdx = opts.cursor ? Number(opts.cursor) : 0;
+    const endIdx = Math.min(startIdx + limit, filtered.length);
+    const slice = filtered.slice(startIdx, endIdx);
+    return {
+      keys: slice,
+      hasMore: endIdx < filtered.length,
+      cursor: endIdx < filtered.length ? String(endIdx) : undefined
+    };
+  }
+  async getSignedUrl(key, _opts = {}) {
+    if (!this.data.has(key))
+      throw new Error(`File not found: ${key}`);
+    return `memory://${encodeURIComponent(key)}`;
+  }
+  async copy(src, dest) {
+    const e = this.data.get(src);
+    if (!e)
+      throw new Error(`File not found: ${src}`);
+    this.data.set(dest, {
+      body: e.body,
+      meta: { ...e.meta, key: dest, lastModified: Date.now() }
+    });
+  }
+  async move(src, dest) {
+    await this.copy(src, dest);
+    this.data.delete(src);
+  }
+}
+function toBuffer(body) {
+  if (typeof body === "string")
+    return Buffer.from(body, "utf-8");
+  return Buffer.isBuffer(body) ? body : Buffer.from(body);
+}
+function simpleEtag(buf) {
+  let h = 5381;
+  for (let i = 0;i < buf.length; i++)
+    h = (h << 5) + h + buf[i] | 0;
+  return `"${(h >>> 0).toString(16)}"`;
+}
+// src/drive/drivers/local.ts
+import {
+  mkdir,
+  readFile,
+  stat,
+  unlink,
+  writeFile,
+  readdir,
+  rename
+} from "fs/promises";
+import { dirname, join, normalize, resolve, sep } from "path";
+
+class LocalDriver {
+  kind = "local";
+  root;
+  publicUrlPrefix;
+  constructor(opts) {
+    this.root = resolve(opts.root);
+    this.publicUrlPrefix = opts.publicUrlPrefix ?? "/files";
+  }
+  resolveKey(key) {
+    const safe = normalize(key).replace(/^[/\\]+/, "");
+    const full = resolve(this.root, safe);
+    if (!full.startsWith(this.root + sep) && full !== this.root) {
+      throw new Error(`Path traversal blocked: ${key}`);
+    }
+    return full;
+  }
+  async put(key, body, _opts = {}) {
+    const path = this.resolveKey(key);
+    await mkdir(dirname(path), { recursive: true });
+    const buf = typeof body === "string" ? Buffer.from(body, "utf-8") : Buffer.from(body);
+    await writeFile(path, buf);
+  }
+  async get(key) {
+    const path = this.resolveKey(key);
+    try {
+      return await readFile(path);
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        throw new Error(`File not found: ${key}`);
+      }
+      throw err;
+    }
+  }
+  async delete(key) {
+    const path = this.resolveKey(key);
+    try {
+      await unlink(path);
+      return true;
+    } catch (err) {
+      if (err.code === "ENOENT")
+        return false;
+      throw err;
+    }
+  }
+  async exists(key) {
+    try {
+      await stat(this.resolveKey(key));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async head(key) {
+    const path = this.resolveKey(key);
+    try {
+      const s = await stat(path);
+      return {
+        key,
+        size: s.size,
+        lastModified: s.mtimeMs
+      };
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        throw new Error(`File not found: ${key}`);
+      }
+      throw err;
+    }
+  }
+  async list(opts = {}) {
+    const root = this.root;
+    const prefix = opts.prefix ?? "";
+    const all = await walk(root, "", prefix);
+    all.sort();
+    const limit = opts.limit ?? 1000;
+    const startIdx = opts.cursor ? Number(opts.cursor) : 0;
+    const endIdx = Math.min(startIdx + limit, all.length);
+    const slice = all.slice(startIdx, endIdx);
+    return {
+      keys: slice,
+      hasMore: endIdx < all.length,
+      cursor: endIdx < all.length ? String(endIdx) : undefined
+    };
+  }
+  async getSignedUrl(key, _opts = {}) {
+    return `${this.publicUrlPrefix}/${key}`;
+  }
+  async copy(src, dest) {
+    const buf = await this.get(src);
+    await this.put(dest, buf);
+  }
+  async move(src, dest) {
+    const from = this.resolveKey(src);
+    const to = this.resolveKey(dest);
+    await mkdir(dirname(to), { recursive: true });
+    await rename(from, to);
+  }
+}
+async function walk(root, dir, prefix) {
+  const out = [];
+  const full = join(root, dir);
+  let entries;
+  try {
+    entries = await readdir(full, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const e of entries) {
+    const rel = dir ? `${dir}/${e.name}` : e.name;
+    if (e.isDirectory()) {
+      if (!prefix || rel === prefix.slice(0, -1) || rel.startsWith(prefix) || prefix.startsWith(`${rel}/`)) {
+        const sub = await walk(root, rel, prefix);
+        out.push(...sub);
+      }
+    } else {
+      if (!prefix || rel.startsWith(prefix)) {
+        out.push(rel);
+      }
+    }
+  }
+  return out;
+}
+// src/drive/drivers/s3.ts
+class S3Driver {
+  kind = "s3";
+  opts;
+  _client = null;
+  _presigner = null;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  async client() {
+    if (this._client)
+      return this._client;
+    try {
+      const mod = await import("@aws-sdk/client-s3");
+      const ctor = mod.S3Client;
+      this._client = new ctor({
+        region: this.opts.region,
+        endpoint: this.opts.endpoint,
+        credentials: this.opts.accessKeyId ? {
+          accessKeyId: this.opts.accessKeyId,
+          secretAccessKey: this.opts.secretAccessKey ?? ""
+        } : undefined
+      });
+    } catch (err) {
+      throw new Error("S3Driver requires @aws-sdk/client-s3. Install it with: bun add @aws-sdk/client-s3");
+    }
+    return this._client;
+  }
+  async presigner() {
+    if (this._presigner)
+      return this._presigner;
+    try {
+      const mod = await import("@aws-sdk/s3-request-presigner");
+      this._presigner = mod.getSignedUrl;
+    } catch {
+      throw new Error("S3Driver signed URLs require @aws-sdk/s3-request-presigner. Install it with: bun add @aws-sdk/s3-request-presigner");
+    }
+    return this._presigner;
+  }
+  async put(key, body, opts = {}) {
+    const client = await this.client();
+    const mod = await import("@aws-sdk/client-s3");
+    const buf = typeof body === "string" ? Buffer.from(body, "utf-8") : Buffer.from(body);
+    const command = new mod.PutObjectCommand({
+      Bucket: this.opts.bucket,
+      Key: key,
+      Body: buf,
+      ContentType: opts.contentType,
+      CacheControl: opts.cacheControl,
+      ACL: opts.acl,
+      Metadata: opts.metadata
+    });
+    await client.send(command);
+  }
+  async get(key) {
+    const client = await this.client();
+    const mod = await import("@aws-sdk/client-s3");
+    const command = new mod.GetObjectCommand({
+      Bucket: this.opts.bucket,
+      Key: key
+    });
+    const res = await client.send(command);
+    const chunks = [];
+    for await (const chunk of res.Body)
+      chunks.push(chunk);
+    return Buffer.concat(chunks);
+  }
+  async delete(key) {
+    const client = await this.client();
+    const mod = await import("@aws-sdk/client-s3");
+    const command = new mod.DeleteObjectCommand({
+      Bucket: this.opts.bucket,
+      Key: key
+    });
+    await client.send(command);
+    return true;
+  }
+  async exists(key) {
+    try {
+      await this.head(key);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async head(key) {
+    const client = await this.client();
+    const mod = await import("@aws-sdk/client-s3");
+    const command = new mod.HeadObjectCommand({
+      Bucket: this.opts.bucket,
+      Key: key
+    });
+    const res = await client.send(command);
+    return {
+      key,
+      size: res.ContentLength ?? 0,
+      contentType: res.ContentType,
+      lastModified: res.LastModified?.getTime() ?? Date.now(),
+      etag: res.ETag
+    };
+  }
+  async list(opts = {}) {
+    const client = await this.client();
+    const mod = await import("@aws-sdk/client-s3");
+    const command = new mod.ListObjectsV2Command({
+      Bucket: this.opts.bucket,
+      Prefix: opts.prefix,
+      MaxKeys: opts.limit,
+      ContinuationToken: opts.cursor
+    });
+    const res = await client.send(command);
+    const keys = (res.Contents ?? []).map((o) => o.Key);
+    return {
+      keys,
+      hasMore: Boolean(res.IsTruncated),
+      cursor: res.NextContinuationToken
+    };
+  }
+  async getSignedUrl(key, opts = {}) {
+    const client = await this.client();
+    const mod = await import("@aws-sdk/client-s3");
+    const presigner = await this.presigner();
+    const expiresIn = opts.expiresIn ?? 3600;
+    const command = new mod.GetObjectCommand({
+      Bucket: this.opts.bucket,
+      Key: key,
+      ResponseContentDisposition: opts.asAttachment ? `attachment; filename="${opts.asAttachment}"` : undefined,
+      ResponseContentType: opts.contentType
+    });
+    return presigner(client, command, { expiresIn });
+  }
+  async copy(src, dest) {
+    const client = await this.client();
+    const mod = await import("@aws-sdk/client-s3");
+    const command = new mod.CopyObjectCommand({
+      Bucket: this.opts.bucket,
+      Key: dest,
+      CopySource: `${this.opts.bucket}/${src}`
+    });
+    await client.send(command);
+  }
+  async move(src, dest) {
+    await this.copy(src, dest);
+    await this.delete(src);
+  }
+}
+// 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/drive/drive.service.ts
+class DriveService {
+  static TOKEN = Symbol.for("nexus:DriveService");
+  _driver;
+  defaultVisibility;
+  signedUrlBuilder;
+  constructor(config = {}) {
+    this._driver = config.driver ?? new MemoryDriver;
+    this.defaultVisibility = config.defaultVisibility ?? "private";
+    this.signedUrlBuilder = config.signedUrlBuilder ?? (async (key, opts) => this._driver.getSignedUrl(key, opts));
+  }
+  get driver() {
+    return this._driver;
+  }
+  async put(key, body, opts) {
+    return this._driver.put(key, body, opts);
+  }
+  async get(key) {
+    return this._driver.get(key);
+  }
+  async delete(key) {
+    return this._driver.delete(key);
+  }
+  async exists(key) {
+    return this._driver.exists(key);
+  }
+  async head(key) {
+    return this._driver.head(key);
+  }
+  async list(opts) {
+    return this._driver.list(opts);
+  }
+  async getSignedUrl(key, opts) {
+    return this.signedUrlBuilder(key, opts);
+  }
+  async copy(src, dest) {
+    return this._driver.copy(src, dest);
+  }
+  async move(src, dest) {
+    return this._driver.move(src, dest);
+  }
+}
+DriveService = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyDecorateParamTS(0, Inject("DRIVE_CONFIG")),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof DriveConfig === "undefined" ? Object : DriveConfig
+  ])
+], DriveService);
+// src/drive/drive.module.ts
+import"reflect-metadata";
+class DriveModule {
+  static forRoot(config = {}) {
+    const cfg = {
+      driver: new MemoryDriver,
+      ...config
+    };
+
+    class ConfiguredDriveModule {
+    }
+    ConfiguredDriveModule = __legacyDecorateClassTS([
+      Module({
+        providers: [
+          DriveService,
+          { provide: DriveService.TOKEN, useExisting: DriveService },
+          { provide: "DRIVE_CONFIG", useValue: cfg }
+        ],
+        exports: [DriveService, DriveService.TOKEN]
+      })
+    ], ConfiguredDriveModule);
+    Object.defineProperty(ConfiguredDriveModule, "name", {
+      value: "ConfiguredDriveModule"
+    });
+    return ConfiguredDriveModule;
+  }
+}
+DriveModule = __legacyDecorateClassTS([
+  Module({
+    providers: [
+      DriveService,
+      { provide: DriveService.TOKEN, useExisting: DriveService }
+    ],
+    exports: [DriveService, DriveService.TOKEN]
+  })
+], DriveModule);
+export {
+  S3Driver,
+  MemoryDriver,
+  LocalDriver,
+  DriveService,
+  DriveModule
+};
+
+//# debugId=C2F94501704A40FC64756E2164756E21
+//# sourceMappingURL=index.js.map