@kabyeon/nexusjs 0.6.5

package/dist/upload/index.js

@@ -0,0 +1,553 @@
+// @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/upload/types.ts
+init_constants();
+import"reflect-metadata";
+
+class UploadError extends Error {
+  status = 400;
+  code;
+  field;
+  constructor(code, field, message) {
+    super(message);
+    this.code = code;
+    this.field = field;
+    this.name = "UploadError";
+  }
+}
+var UPLOAD_STORAGE_KEY = "nexus:upload:files";
+var UPLOAD_META = "nexus:upload:options";
+// 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/upload/upload.service.ts
+class UploadService {
+  static TOKEN = Symbol.for("nexus:UploadService");
+  #config;
+  #driveResolver = null;
+  constructor(config = {}) {
+    this.#config = {
+      maxFileSize: config.maxFileSize ?? 10 * 1024 * 1024,
+      maxFiles: config.maxFiles ?? 5,
+      allowedMimeTypes: config.allowedMimeTypes ?? ["*"],
+      storage: config.storage ?? "memory",
+      driveToken: config.driveToken ?? "",
+      drivePrefix: config.drivePrefix ?? "",
+      preserveFilename: config.preserveFilename ?? false
+    };
+  }
+  bindDriveResolver(fn) {
+    this.#driveResolver = fn;
+  }
+  getConfig() {
+    return { ...this.#config };
+  }
+  async parseAndStore(c, fields) {
+    const body = await this.#parseBody(c);
+    const stored = {};
+    for (const spec of fields) {
+      const value = body[spec.fieldName];
+      const files = this.#extractFiles(value);
+      if (files.length === 0) {
+        if (spec.required) {
+          throw new UploadError("MISSING_FIELD", spec.fieldName, `Missing required field "${spec.fieldName}".`);
+        }
+        continue;
+      }
+      if (files.length > spec.maxFiles) {
+        throw new UploadError("TOO_MANY_FILES", spec.fieldName, `Field "${spec.fieldName}" accepts at most ${spec.maxFiles} files (got ${files.length}).`);
+      }
+      for (const f of files) {
+        this.#validate(f, spec.fieldName);
+      }
+      stored[spec.fieldName] = files.length === 1 ? files[0] : files;
+    }
+    c.set(UPLOAD_STORAGE_KEY, stored);
+    if (this.#config.driveToken && this.#driveResolver) {
+      const drive = this.#driveResolver(this.#config.driveToken);
+      if (drive?.put) {
+        for (const [, entry] of Object.entries(stored)) {
+          const list = Array.isArray(entry) ? entry : [entry];
+          for (const file of list) {
+            const filename = this.#config.preserveFilename ? file.filename : this.#newFilename(file);
+            const key = `${this.#config.drivePrefix}/${filename}`;
+            await drive.put(key, file.buffer, {
+              contentType: file.contentType
+            });
+            file.storedKey = key;
+          }
+        }
+      }
+    }
+  }
+  get(c, fieldName) {
+    const stored = c.get(UPLOAD_STORAGE_KEY);
+    if (!stored)
+      return;
+    const v = stored[fieldName];
+    if (Array.isArray(v))
+      return v[0];
+    return v;
+  }
+  getAll(c, fieldName) {
+    const stored = c.get(UPLOAD_STORAGE_KEY);
+    if (!stored)
+      return [];
+    const v = stored[fieldName];
+    if (Array.isArray(v))
+      return v;
+    if (v)
+      return [v];
+    return [];
+  }
+  async#parseBody(c) {
+    const req = c.req?.raw ?? c.req;
+    const ct = req.headers?.get?.("content-type") ?? "";
+    if (!ct.startsWith("multipart/form-data")) {
+      return {};
+    }
+    try {
+      return await c.req.parseBody({ all: true });
+    } catch (err) {
+      throw new UploadError("BAD_MULTIPART", "*", `Failed to parse multipart body: ${err.message}`);
+    }
+  }
+  #extractFiles(value) {
+    if (value === undefined || value === null)
+      return [];
+    const list = Array.isArray(value) ? value : [value];
+    const out = [];
+    for (const v of list) {
+      if (typeof v === "string")
+        continue;
+      if (typeof v !== "object")
+        continue;
+      const file = v;
+      if (typeof file.arrayBuffer !== "function")
+        continue;
+      const filename = file.filename ?? file.name ?? "upload";
+      const contentType = file.type ?? "application/octet-stream";
+      out.push({
+        fieldName: file.name,
+        filename,
+        contentType,
+        encoding: "7bit",
+        buffer: Buffer.alloc(0),
+        size: file.size ?? 0
+      });
+    }
+    return out;
+  }
+  #validate(file, fieldName) {
+    if (file.size > this.#config.maxFileSize) {
+      throw new UploadError("FILE_TOO_LARGE", fieldName, `File "${file.filename}" is ${file.size} bytes; max is ${this.#config.maxFileSize}.`);
+    }
+    if (!this.#mimeAllowed(file.contentType)) {
+      throw new UploadError("MIME_NOT_ALLOWED", fieldName, `File "${file.filename}" has type "${file.contentType}"; not in the allow list.`);
+    }
+  }
+  #mimeAllowed(mime) {
+    for (const pat of this.#config.allowedMimeTypes) {
+      if (pat === "*")
+        return true;
+      if (pat === mime)
+        return true;
+      if (pat.endsWith("/*")) {
+        const prefix = pat.slice(0, -2);
+        if (mime.startsWith(prefix))
+          return true;
+      }
+    }
+    return false;
+  }
+  #newFilename(file) {
+    const ext = file.filename.includes(".") ? file.filename.slice(file.filename.lastIndexOf(".")) : "";
+    const stamp = Date.now().toString(36);
+    const rand = Math.random().toString(36).slice(2, 8);
+    return `${stamp}-${rand}${ext}`;
+  }
+}
+UploadService = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyDecorateParamTS(0, Inject("UPLOAD_CONFIG")),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof UploadConfig === "undefined" ? Object : UploadConfig
+  ])
+], UploadService);
+// src/upload/upload.module.ts
+import"reflect-metadata";
+
+// src/upload/upload.middleware.ts
+function uploadMiddleware(svc) {
+  return async (c, next) => {
+    const ct = c.req?.raw?.headers?.get?.("content-type") ?? "";
+    if (!ct.startsWith("multipart/form-data"))
+      return next();
+    const fields = c.get?.("uploadFields") ?? [];
+    if (fields.length === 0)
+      return next();
+    try {
+      await svc.parseAndStore(c, fields);
+      return next();
+    } catch (err) {
+      if (err instanceof UploadError) {
+        return c.json({ error: err.message, code: err.code, field: err.field }, err.status);
+      }
+      throw err;
+    }
+  };
+}
+
+// src/upload/upload.module.ts
+class UploadModule {
+  static forRoot(config = {}) {
+    class ConfiguredUploadModule {
+    }
+    ConfiguredUploadModule = __legacyDecorateClassTS([
+      Module({
+        providers: [
+          UploadService,
+          { provide: UploadService.TOKEN, useExisting: UploadService },
+          { provide: "UPLOAD_CONFIG", useValue: config }
+        ],
+        exports: [UploadService, UploadService.TOKEN]
+      })
+    ], ConfiguredUploadModule);
+    Object.defineProperty(ConfiguredUploadModule, "name", {
+      value: "ConfiguredUploadModule"
+    });
+    return ConfiguredUploadModule;
+  }
+  static mount(app, svc, routes = []) {
+    const fieldSet = new Map;
+    for (const r of routes) {
+      const metas = Reflect.getMetadata("nexus:upload:options", r.target.constructor, r.propertyKey) ?? [];
+      for (const m of metas) {
+        const existing = fieldSet.get(m.name);
+        const maxFiles = m.options?.maxFiles ?? 1;
+        const required = m.options?.required ?? true;
+        if (!existing || maxFiles > existing.maxFiles) {
+          fieldSet.set(m.name, { maxFiles, required: existing?.required ?? required });
+        }
+      }
+    }
+    app.use("/**", async (c, next) => {
+      const fields = [];
+      for (const [name, info] of fieldSet.entries()) {
+        fields.push({ fieldName: name, ...info });
+      }
+      c.set("uploadFields", fields);
+      return uploadMiddleware(svc)(c, next);
+    });
+  }
+}
+UploadModule = __legacyDecorateClassTS([
+  Module({
+    providers: [
+      UploadService,
+      { provide: UploadService.TOKEN, useExisting: UploadService }
+    ],
+    exports: [UploadService, UploadService.TOKEN]
+  })
+], UploadModule);
+// src/upload/decorators/upload.ts
+import"reflect-metadata";
+var DEFAULT_NAME = "__upload__";
+function Upload(name = DEFAULT_NAME, options = {}) {
+  return (target, propertyKey) => {
+    const existing = Reflect.getMetadata(UPLOAD_META, target.constructor, propertyKey) ?? [];
+    existing.push({ name, options });
+    Reflect.defineMetadata(UPLOAD_META, existing, target.constructor, propertyKey);
+  };
+}
+// src/upload/decorators/uploaded-file.ts
+init_params();
+var UploadedFile = (fieldName) => createParamDecorator(128, fieldName);
+function getUploadedFile(c, fieldName) {
+  const stored = c.get?.(UPLOAD_STORAGE_KEY) ?? c.var?.[UPLOAD_STORAGE_KEY];
+  if (!stored)
+    return;
+  const v = stored[fieldName];
+  if (Array.isArray(v))
+    return v[0];
+  return v;
+}
+function getUploadedFiles(c, fieldName) {
+  const stored = c.get?.(UPLOAD_STORAGE_KEY) ?? c.var?.[UPLOAD_STORAGE_KEY];
+  if (!stored)
+    return [];
+  const v = stored[fieldName];
+  if (Array.isArray(v))
+    return v;
+  if (v)
+    return [v];
+  return [];
+}
+export {
+  uploadMiddleware,
+  getUploadedFiles,
+  getUploadedFile,
+  UploadedFile,
+  UploadService,
+  UploadModule,
+  UploadError,
+  Upload,
+  UPLOAD_STORAGE_KEY,
+  UPLOAD_META,
+  METADATA_KEY
+};
+
+//# debugId=3B694CB87049E44264756E2164756E21
+//# sourceMappingURL=index.js.map