nesties 1.1.1 → 1.1.3

package/build.js

@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+/* build.js - node build.js [all|cjs|esm|types|clean] */
+const fs = require('fs');
+const path = require('path');
+const { builtinModules } = require('module');
+
+const DIST_DIR = 'dist';
+
+/* ------------------------- utils ------------------------- */
+function readJSONSafe(file, fallback = {}) {
+  try {
+    const p = path.resolve(process.cwd(), file);
+    const txt = fs.readFileSync(p, 'utf8');
+    return JSON.parse(txt);
+  } catch {
+    return fallback;
+  }
+}
+function uniq(arr) { return Array.from(new Set(arr)); }
+function ensureDir(p) { fs.mkdirSync(p, { recursive: true }); }
+function rimraf(p) { if (fs.existsSync(p)) fs.rmSync(p, { recursive: true, force: true }); }
+
+function depsAsExternal(pkg) {
+  const dep = Object.keys(pkg.dependencies || {});
+  const peer = Object.keys(pkg.peerDependencies || {});
+  const names = uniq([...dep, ...peer]);
+  // 覆盖子路径导入（lodash/fp、react/jsx-runtime）
+  return uniq(names.flatMap((n) => [n, `${n}/*`]));
+}
+function nodeBuiltinsExternal() {
+  // 既包含 'fs' 也包含 'node:fs' 形式
+  return uniq([...builtinModules, ...builtinModules.map((m) => `node:${m}`)]);
+}
+async function loadEsbuild() {
+  try { return require('esbuild'); }
+  catch { const mod = await import('esbuild'); return mod.build ? mod : mod.default; }
+}
+function tsconfigPath() { return fs.existsSync('tsconfig.json') ? 'tsconfig.json' : undefined; }
+function entryPointsFromPkg(/*pkg*/) { return ['index.ts']; }
+
+/* ------------------------- esbuild builds ------------------------- */
+async function buildOne(format, options) {
+  const esbuild = await loadEsbuild();
+  const { external, tsconfig, entryPoints } = options;
+  const isCjs = format === 'cjs';
+  const outfile = path.join(DIST_DIR, isCjs ? 'index.cjs' : 'index.mjs');
+
+  ensureDir(path.dirname(outfile));
+  console.log(`[build] ${format} -> ${outfile}`);
+
+  await esbuild.build({
+    entryPoints,
+    outfile,
+    bundle: true,
+    sourcemap: true,
+    format, // 'cjs' | 'esm'
+    platform: isCjs ? 'node' : 'neutral',
+    target: isCjs ? 'es2021' : 'esnext',
+    external, // deps + peerDeps + node builtins (含 node:*)
+    logLevel: 'info',
+    ...(tsconfig ? { tsconfig } : {}),
+  });
+}
+
+/* ------------------------- types via TypeScript API ------------------------- */
+function buildTypesAPI(outDir = DIST_DIR) {
+  let ts;
+  try { ts = require('typescript'); }
+  catch {
+    console.error('[types] Missing dependency: typescript');
+    process.exit(1);
+  }
+
+  const cfgPath = ts.findConfigFile('./', ts.sys.fileExists, 'tsconfig.json');
+
+  let fileNames, options;
+  if (cfgPath) {
+    // 读取 tsconfig.json
+    const { config } = ts.readConfigFile(cfgPath, ts.sys.readFile);
+    const parsed = ts.parseJsonConfigFileContent(config, ts.sys, path.dirname(cfgPath));
+    fileNames = parsed.fileNames;
+    options = parsed.options;
+  } else {
+    // 没有 tsconfig 的降级：仅用 index.ts
+    console.warn('[types] tsconfig.json not found; fallback to index.ts with basic options.');
+    fileNames = ['index.ts'].filter((f) => fs.existsSync(f));
+    options = {
+      moduleResolution: 99, // NodeNext（避免引入 enum 名字，用常量值）
+      target: 99,          // ESNext
+      skipLibCheck: true,
+      strict: true,
+    };
+  }
+
+  // 强制仅输出声明
+  options.declaration = true;
+  options.emitDeclarationOnly = true;
+  options.outDir = outDir;
+  // 为了不受 sourceMap/emit 等其它设置影响
+  options.noEmitOnError = false;
+
+  console.log('[types] Generating .d.ts ...');
+  const program = ts.createProgram(fileNames, options);
+  const pre = ts.getPreEmitDiagnostics(program);
+  const emitResult = program.emit();
+  const diagnostics = pre.concat(emitResult.diagnostics);
+
+  if (diagnostics.length) {
+    const formatHost = {
+      getCanonicalFileName: (p) => p,
+      getCurrentDirectory: ts.sys.getCurrentDirectory,
+      getNewLine: () => ts.sys.newLine,
+    };
+    const message = ts.formatDiagnosticsWithColorAndContext(diagnostics, formatHost);
+    console.error(message);
+    if (emitResult.emitSkipped) {
+      throw new Error('[types] Type generation failed.');
+    }
+  }
+  console.log('[types] Declarations generated.');
+}
+
+/* ------------------------- main dispatcher ------------------------- */
+(async function main() {
+  const sub = (process.argv[2] || 'all').toLowerCase(); // all | cjs | esm | types | clean
+
+  const pkg = readJSONSafe('package.json');
+  const externalFromPkg = depsAsExternal(pkg);
+  // 统一 external：依赖 + peer + Node 内置（含 node:*）
+  const external = uniq([...externalFromPkg, ...nodeBuiltinsExternal()]);
+  const tscPath = tsconfigPath();
+  const entryPoints = entryPointsFromPkg(pkg);
+
+  switch (sub) {
+    case 'clean': {
+      console.log('[clean] remove dist/');
+      rimraf(DIST_DIR);
+      break;
+    }
+    case 'cjs': {
+      await buildOne('cjs', { external, tsconfig: tscPath, entryPoints });
+      break;
+    }
+    case 'esm': {
+      await buildOne('esm', { external, tsconfig: tscPath, entryPoints });
+      break;
+    }
+    case 'types': {
+      ensureDir(DIST_DIR);
+      buildTypesAPI(DIST_DIR);
+      break;
+    }
+    case 'all':
+    default: {
+      console.log('[clean] remove dist/');
+      rimraf(DIST_DIR);
+      await buildOne('cjs', { external, tsconfig: tscPath, entryPoints });
+      await buildOne('esm', { external, tsconfig: tscPath, entryPoints });
+      buildTypesAPI(DIST_DIR);
+      console.log('[build] Done.');
+      break;
+    }
+  }
+})().catch((err) => {
+  console.error('[build] Failed:', err);
+  process.exit(1);
+});

package/dist/index.cjs

@@ -0,0 +1,483 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  ABORT_SIGNAL: () => ABORT_SIGNAL,
+  AbortSignalProvider: () => AbortSignalProvider,
+  AbortableModule: () => AbortableModule,
+  ApiBlankResponse: () => ApiBlankResponse,
+  ApiError: () => ApiError,
+  ApiErrorTyped: () => ApiErrorTyped,
+  ApiTypeResponse: () => ApiTypeResponse,
+  As: () => As,
+  BlankPaginatedReturnMessageDto: () => BlankPaginatedReturnMessageDto,
+  BlankReturnMessageDto: () => BlankReturnMessageDto,
+  DataBody: () => DataBody,
+  DataPipe: () => DataPipe,
+  DataQuery: () => DataQuery,
+  GenericPaginatedReturnMessageDto: () => GenericPaginatedReturnMessageDto,
+  GenericReturnMessageDto: () => GenericReturnMessageDto,
+  InjectAbortSignal: () => InjectAbortSignal,
+  InjectAbortable: () => InjectAbortable,
+  InsertField: () => InsertField,
+  MergeClassDecorators: () => MergeClassDecorators,
+  MergeClassOrMethodDecorators: () => MergeClassOrMethodDecorators,
+  MergeMethodDecorators: () => MergeMethodDecorators,
+  MergeParameterDecorators: () => MergeParameterDecorators,
+  MergePropertyDecorators: () => MergePropertyDecorators,
+  PaginatedReturnMessageDto: () => PaginatedReturnMessageDto,
+  RequireToken: () => RequireToken,
+  ReturnMessageDto: () => ReturnMessageDto,
+  StringReturnMessageDto: () => StringReturnMessageDto,
+  TokenGuard: () => TokenGuard,
+  abortableToken: () => abortableToken,
+  createAbortableProvider: () => createAbortableProvider,
+  fromAbortable: () => fromAbortable,
+  getClassFromClassOrArray: () => getClassFromClassOrArray,
+  takeUntilAbort: () => takeUntilAbort
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/insert-field.ts
+var import_swagger = require("@nestjs/swagger");
+function getClassFromClassOrArray(o) {
+  return o instanceof Array ? o[0] : o;
+}
+function InsertField(cl, map, newName) {
+  const extendedCl = class extends cl {
+  };
+  for (const key in map) {
+    (0, import_swagger.ApiProperty)({
+      type: map[key].type,
+      ...map[key].options || {}
+    })(extendedCl.prototype, key);
+  }
+  Object.defineProperty(extendedCl, "name", {
+    value: newName || cl.name
+  });
+  return extendedCl;
+}
+
+// src/merge.ts
+function MergePropertyDecorators(decs) {
+  return (obj, key) => {
+    for (const dec of decs) {
+      dec(obj, key);
+    }
+  };
+}
+function MergeMethodDecorators(decs) {
+  return (obj, key, descriptor) => {
+    for (const dec of decs) {
+      dec(obj, key, descriptor);
+    }
+  };
+}
+function MergeClassDecorators(decs) {
+  return (obj) => {
+    for (const dec of decs) {
+      dec(obj);
+    }
+  };
+}
+function MergeParameterDecorators(decs) {
+  return (obj, key, index) => {
+    for (const dec of decs) {
+      dec(obj, key, index);
+    }
+  };
+}
+function MergeClassOrMethodDecorators(decs) {
+  return (obj, key, descriptor) => {
+    if (descriptor) {
+      for (const dec of decs) {
+        dec(obj, key, descriptor);
+      }
+    } else {
+      for (const dec of decs) {
+        dec(obj);
+      }
+    }
+  };
+}
+
+// src/return-message.ts
+var import_swagger2 = require("@nestjs/swagger");
+var import_common = require("@nestjs/common");
+var BlankReturnMessageDto = class {
+  constructor(statusCode, message) {
+    this.statusCode = statusCode;
+    this.message = message || "success";
+    this.success = statusCode < 400;
+    this.timestamp = /* @__PURE__ */ new Date();
+  }
+  toException() {
+    return new import_common.HttpException(this, this.statusCode);
+  }
+};
+__decorateClass([
+  (0, import_swagger2.ApiProperty)({ description: "Return code", type: Number })
+], BlankReturnMessageDto.prototype, "statusCode", 2);
+__decorateClass([
+  (0, import_swagger2.ApiProperty)({ description: "Return message", type: String })
+], BlankReturnMessageDto.prototype, "message", 2);
+__decorateClass([
+  (0, import_swagger2.ApiProperty)({ description: "Whether success.", type: Boolean })
+], BlankReturnMessageDto.prototype, "success", 2);
+__decorateClass([
+  (0, import_swagger2.ApiProperty)({ description: "Return timestamp", type: Date })
+], BlankReturnMessageDto.prototype, "timestamp", 2);
+var BlankPaginatedReturnMessageDto = class extends BlankReturnMessageDto {
+  constructor(statusCode, message, total, pageSettings) {
+    super(statusCode, message);
+    this.total = total;
+    this.pageCount = pageSettings.pageCount;
+    this.recordsPerPage = pageSettings.recordsPerPage;
+    this.totalPages = Math.ceil(total / pageSettings.recordsPerPage);
+  }
+};
+__decorateClass([
+  (0, import_swagger2.ApiProperty)({ description: "Total record count.", type: Number })
+], BlankPaginatedReturnMessageDto.prototype, "total", 2);
+__decorateClass([
+  (0, import_swagger2.ApiProperty)({ description: "Total page count.", type: Number })
+], BlankPaginatedReturnMessageDto.prototype, "totalPages", 2);
+__decorateClass([
+  (0, import_swagger2.ApiProperty)({ description: "Current page.", type: Number })
+], BlankPaginatedReturnMessageDto.prototype, "pageCount", 2);
+__decorateClass([
+  (0, import_swagger2.ApiProperty)({ description: "Records per page.", type: Number })
+], BlankPaginatedReturnMessageDto.prototype, "recordsPerPage", 2);
+var GenericReturnMessageDto = class extends BlankReturnMessageDto {
+  constructor(statusCode, message, data) {
+    super(statusCode, message);
+    this.data = data;
+  }
+};
+function ReturnMessageDto(type) {
+  return InsertField(
+    GenericReturnMessageDto,
+    {
+      data: {
+        type,
+        options: {
+          required: false,
+          description: "Return data."
+        }
+      }
+    },
+    `${getClassFromClassOrArray(type).name}${Array.isArray(type) ? "Array" : ""}ReturnMessageDto`
+  );
+}
+var GenericPaginatedReturnMessageDto = class extends BlankPaginatedReturnMessageDto {
+  constructor(statusCode, message, data, total, pageSettings) {
+    super(statusCode, message, total, pageSettings);
+    this.data = data;
+  }
+};
+function PaginatedReturnMessageDto(type) {
+  return InsertField(
+    GenericPaginatedReturnMessageDto,
+    {
+      data: {
+        type: [type],
+        options: {
+          required: false,
+          description: "Return data."
+        }
+      }
+    },
+    `${getClassFromClassOrArray(type).name}PaginatedReturnMessageDto`
+  );
+}
+var StringReturnMessageDto = class extends GenericReturnMessageDto {
+};
+__decorateClass([
+  (0, import_swagger2.ApiProperty)({ description: "Return data.", type: String, required: false })
+], StringReturnMessageDto.prototype, "data", 2);
+
+// src/openapi.ts
+var import_swagger3 = require("@nestjs/swagger");
+var ApiTypeResponse = (type, options = {}) => (0, import_swagger3.ApiResponse)({
+  status: 200,
+  type: ReturnMessageDto(type),
+  ...options
+});
+var ApiBlankResponse = (options = {}) => (0, import_swagger3.ApiResponse)({
+  status: 200,
+  type: BlankReturnMessageDto,
+  ...options
+});
+var ApiError = (status, description) => ApiBlankResponse({ status, description });
+var ApiErrorTyped = (status, description, type) => ApiTypeResponse(type, {
+  status,
+  description
+});
+
+// src/pipe.ts
+var import_common2 = require("@nestjs/common");
+var DataPipe = () => new import_common2.ValidationPipe({
+  transform: true,
+  transformOptions: { enableImplicitConversion: true }
+});
+var createDataPipeDec = (nestFieldDec) => (...extraPipes) => nestFieldDec(DataPipe(), ...extraPipes);
+var DataQuery = createDataPipeDec(import_common2.Query);
+var DataBody = createDataPipeDec(import_common2.Body);
+
+// src/token.guard.ts
+var import_common3 = require("@nestjs/common");
+var import_swagger4 = require("@nestjs/swagger");
+var TokenGuard = class {
+  constructor(config) {
+    this.config = config;
+    this.token = this.config.get("SERVER_TOKEN");
+  }
+  async canActivate(context) {
+    const request = context.switchToHttp().getRequest();
+    const token = request.headers["x-server-token"];
+    if (this.token && token !== this.token) {
+      throw new BlankReturnMessageDto(401, "Unauthorized").toException();
+    }
+    return true;
+  }
+};
+TokenGuard = __decorateClass([
+  (0, import_common3.Injectable)()
+], TokenGuard);
+var RequireToken = () => MergeClassOrMethodDecorators([
+  (0, import_common3.UseGuards)(TokenGuard),
+  (0, import_swagger4.ApiHeader)({
+    name: "x-server-token",
+    description: "Server token",
+    required: false
+  }),
+  ApiError(401, "Incorrect server token provided")
+]);
+
+// src/abort-utils.ts
+var import_rxjs = require("rxjs");
+var import_common4 = require("@nestjs/common");
+
+// src/abort-http-signal.ts
+function toRawReq(req) {
+  if (req?.raw?.socket) return req.raw;
+  return req;
+}
+function createAbortSignalFromHttp(req) {
+  const rawReq = toRawReq(req);
+  const ac = new AbortController();
+  const makeReason = () => new BlankReturnMessageDto(499, "Request aborted").toException();
+  const abortOnce = () => {
+    if (!ac.signal.aborted) ac.abort(makeReason());
+    cleanup();
+  };
+  const onClose = () => {
+    abortOnce();
+  };
+  const cleanup = () => {
+    rawReq.off?.("close", onClose);
+  };
+  rawReq.once?.("close", onClose);
+  return ac.signal;
+}
+
+// src/abort-utils.ts
+var fromAbortable = (fn) => {
+  return new import_rxjs.Observable((subscriber) => {
+    const ac = new AbortController();
+    fn(ac).then(
+      (value) => {
+        if (!ac.signal.aborted && !subscriber.closed) {
+          subscriber.next(value);
+          subscriber.complete();
+        }
+      },
+      (err) => {
+        if (ac.signal.aborted) {
+          if (!subscriber.closed) subscriber.complete();
+          return;
+        }
+        if (!subscriber.closed) subscriber.error(err);
+      }
+    );
+    return () => {
+      if (!ac.signal.aborted) ac.abort();
+    };
+  });
+};
+var takeUntilAbort = (signal) => {
+  return (source) => {
+    return source.pipe(
+      (0, import_rxjs.takeUntil)(
+        new import_rxjs.Observable((subscriber) => {
+          const onAbort = () => subscriber.next();
+          if (signal.aborted) {
+            subscriber.next();
+          } else {
+            signal.addEventListener("abort", onAbort, { once: true });
+          }
+          return () => signal.removeEventListener("abort", onAbort);
+        })
+      )
+    );
+  };
+};
+var As = (0, import_common4.createParamDecorator)(
+  (_data, ctx) => {
+    const req = ctx.switchToHttp().getRequest();
+    return createAbortSignalFromHttp(req);
+  }
+);
+
+// src/abortable-module/abortable.token.ts
+var import_common6 = require("@nestjs/common");
+var import_nfkit = require("nfkit");
+
+// src/abortable-module/abort-signal.provider.ts
+var import_common5 = require("@nestjs/common");
+var import_core = require("@nestjs/core");
+var ABORT_SIGNAL = Symbol("ABORT_SIGNAL");
+var AbortSignalProvider = {
+  provide: ABORT_SIGNAL,
+  scope: import_common5.Scope.REQUEST,
+  inject: [import_core.REQUEST],
+  useFactory: (req) => {
+    return createAbortSignalFromHttp(req);
+  }
+};
+var InjectAbortSignal = () => (0, import_common5.Inject)(ABORT_SIGNAL);
+
+// src/abortable-module/abortable.token.ts
+var import_core2 = require("@nestjs/core");
+var tokenMemo = /* @__PURE__ */ new Map();
+var abortableToken = (token) => {
+  if (tokenMemo.has(token)) return tokenMemo.get(token);
+  const name = typeof token === "function" ? token.name : String(token);
+  const sym = Symbol.for(`Abortable(${name})`);
+  tokenMemo.set(token, sym);
+  return sym;
+};
+function InjectAbortable(token) {
+  return (target, propertyKey, parameterIndex) => {
+    let actualToken = token;
+    if (!actualToken) {
+      const paramTypes = Reflect.getMetadata("design:paramtypes", target, propertyKey) || [];
+      actualToken = paramTypes[parameterIndex];
+      if (!actualToken) {
+        throw new Error(
+          `@InjectAbortable() cannot infer type from metadata: ${target.constructor?.name}[${parameterIndex}]`
+        );
+      }
+    }
+    (0, import_common6.Inject)(abortableToken(actualToken))(target, propertyKey, parameterIndex);
+  };
+}
+function createAbortableProvider(token, opts) {
+  const provide = abortableToken(token);
+  return {
+    provide,
+    scope: import_common6.Scope.REQUEST,
+    inject: [import_core2.ModuleRef, import_core2.REQUEST, ABORT_SIGNAL],
+    // ⚠️ 注意：用 async + resolve + contextId + strict:false
+    useFactory: async (moduleRef, req, signal) => {
+      const ctxId = import_core2.ContextIdFactory.getByRequest(req);
+      const svc = await moduleRef.resolve(token, ctxId, { strict: false });
+      if (svc == null) {
+        throw new Error(
+          `Abortable: provider "${String(
+            token.name ?? token
+          )}" not found in container (even with strict:false)`
+        );
+      }
+      return (0, import_nfkit.abortable)(svc, signal, opts);
+    }
+  };
+}
+
+// src/abortable-module/abortable.module.ts
+var import_common7 = require("@nestjs/common");
+var AbortableModule = class {
+  static forRoot() {
+    return {
+      module: AbortableModule,
+      providers: [AbortSignalProvider],
+      exports: [AbortSignalProvider],
+      global: true
+    };
+  }
+  static forFeature(tokens, options) {
+    const providers = tokens.map(
+      (token) => createAbortableProvider(token, options?.abortableOptions)
+    );
+    return {
+      module: AbortableModule,
+      providers: [...providers],
+      exports: [...providers]
+    };
+  }
+};
+AbortableModule = __decorateClass([
+  (0, import_common7.Module)({})
+], AbortableModule);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ABORT_SIGNAL,
+  AbortSignalProvider,
+  AbortableModule,
+  ApiBlankResponse,
+  ApiError,
+  ApiErrorTyped,
+  ApiTypeResponse,
+  As,
+  BlankPaginatedReturnMessageDto,
+  BlankReturnMessageDto,
+  DataBody,
+  DataPipe,
+  DataQuery,
+  GenericPaginatedReturnMessageDto,
+  GenericReturnMessageDto,
+  InjectAbortSignal,
+  InjectAbortable,
+  InsertField,
+  MergeClassDecorators,
+  MergeClassOrMethodDecorators,
+  MergeMethodDecorators,
+  MergeParameterDecorators,
+  MergePropertyDecorators,
+  PaginatedReturnMessageDto,
+  RequireToken,
+  ReturnMessageDto,
+  StringReturnMessageDto,
+  TokenGuard,
+  abortableToken,
+  createAbortableProvider,
+  fromAbortable,
+  getClassFromClassOrArray,
+  takeUntilAbort
+});
+//# sourceMappingURL=index.cjs.map