phecda-server 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 fgsreally
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/client/index.d.ts

@@ -0,0 +1,27 @@
+import { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
+import { R as RequestType, a as ResOrErr, P as PError } from '../types-6e2842b3.js';
+
+interface RequestArgs {
+    body: Record<string, any>;
+    query: Record<string, string>;
+    params: Record<string, string>;
+    realParam: string;
+    method: RequestType;
+    url: string;
+    name: string;
+}
+type MergedReqArg = Pick<RequestArgs, 'body' | 'query' | 'params'>;
+declare function toReq(arg: RequestArgs): {
+    method: RequestType;
+    url: string;
+    body: Record<string, any>;
+    query: string;
+    params: string;
+};
+declare const merge: (...args: RequestArgs[]) => Record<string, MergedReqArg>;
+type RequestMethod = <F extends (...args: any[]) => any>(fn: F, args: Parameters<F>) => Promise<ReturnType<F>>;
+declare function createReq(instance: AxiosInstance): <R>(arg: R, config?: AxiosRequestConfig) => Promise<AxiosResponse<Awaited<R>>>;
+declare function createMergeReq(instance: AxiosInstance, key?: string): <R extends unknown[]>(args: R, config?: AxiosRequestConfig) => Promise<AxiosResponse<ResOrErr<R>>>;
+declare function isError<T = any>(data: T | PError): data is PError;
+
+export { RequestMethod, createMergeReq, createReq, isError, merge, toReq };

package/dist/client/index.js

@@ -0,0 +1,88 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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);
+
+// src/client/index.ts
+var client_exports = {};
+__export(client_exports, {
+  createMergeReq: () => createMergeReq,
+  createReq: () => createReq,
+  isError: () => isError,
+  merge: () => merge,
+  toReq: () => toReq
+});
+module.exports = __toCommonJS(client_exports);
+function toReq(arg) {
+  const { body, query, realParam, method, url } = arg;
+  return {
+    method,
+    url,
+    body,
+    query: Object.keys(query).length > 0 ? `?${Object.entries(query).map(([k, v]) => `${k}=${v}`).join("&")}` : "",
+    params: realParam
+  };
+}
+__name(toReq, "toReq");
+var merge = /* @__PURE__ */ __name((...args) => {
+  const ret = {};
+  for (const i of args) {
+    const { name, body, query, params } = i;
+    ret[name] = {
+      body,
+      query,
+      params
+    };
+  }
+  return ret;
+}, "merge");
+function createReq(instance) {
+  return (arg, config) => {
+    const { url, params, query, body, method } = toReq(arg);
+    if (!method) {
+      console.warn("methods without route decorator won't send request");
+      return;
+    }
+    const ret = [
+      `${url}${params}${query}`
+    ];
+    body && ret.push(body);
+    config && ret.push(config);
+    return instance[method](...ret);
+  };
+}
+__name(createReq, "createReq");
+function createMergeReq(instance, key = "/__PHECDA_SERVER__") {
+  return (args, config) => {
+    return instance.post(key, merge(...args), config);
+  };
+}
+__name(createMergeReq, "createMergeReq");
+function isError(data) {
+  return typeof data === "object" && data.error;
+}
+__name(isError, "isError");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createMergeReq,
+  createReq,
+  isError,
+  merge,
+  toReq
+});
+//# sourceMappingURL=index.js.map

package/dist/client/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/client/index.ts"],"sourcesContent":["import type { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios'\nimport type { PError, RequestType, ResOrErr } from '../types'\ninterface RequestArgs {\n  body: Record<string, any>\n  query: Record<string, string>\n  params: Record<string, string>\n  realParam: string\n  method: RequestType\n  url: string\n  name: string\n}\ntype MergedReqArg = Pick<RequestArgs, 'body' | 'query' | 'params'>\nexport function toReq(arg: RequestArgs) {\n  const { body, query, realParam, method, url } = arg\n  return { method, url, body, query: Object.keys(query).length > 0 ? `?${Object.entries(query).map(([k, v]) => `${k}=${v}`).join('&')}` : '', params: realParam }\n}\n\nexport const merge = (...args: RequestArgs[]) => {\n  const ret = {} as Record<string, MergedReqArg>\n  for (const i of args) {\n    const { name, body, query, params } = i\n    ret[name] = { body, query, params }\n  }\n\n  return ret\n}\n\nexport type RequestMethod = <F extends (...args: any[]) => any >(fn: F, args: Parameters<F>) => Promise<ReturnType<F>>\n\nexport function createReq(instance: AxiosInstance): <R>(arg: R, config?: AxiosRequestConfig) => Promise<AxiosResponse<Awaited<R>> > {\n  // @ts-expect-error methods without route decorator won't send request\n  return (arg: any, config?: AxiosRequestConfig) => {\n    const { url, params, query, body, method } = toReq(arg as RequestArgs)\n    if (!method) {\n      console.warn('methods without route decorator won\\'t send request')\n      return\n    }\n\n    const ret = [`${url}${params}${query}`] as any[]\n    body && ret.push(body)\n    config && ret.push(config)\n    // @ts-expect-error misdirction\n    return instance[method](...ret)\n  }\n}\n\nexport function createMergeReq(instance: AxiosInstance, key = '/__PHECDA_SERVER__'): < R extends unknown[]>(args: R, config?: AxiosRequestConfig) => Promise<AxiosResponse<ResOrErr<R>>> {\n  // @ts-expect-error misdirction\n  return (args: RequestArgs[], config?: AxiosRequestConfig) => {\n    return instance.post(key, merge(...args), config)\n  }\n}\n\nexport function isError<T = any>(data: T | PError): data is PError {\n  return typeof data === 'object' && (data as any).error\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAYA;;;;;;;;;AAAO,SAASA,MAAMC,KAAkB;AACtC,QAAM,EAAEC,MAAMC,OAAOC,WAAWC,QAAQC,IAAG,IAAKL;AAChD,SAAO;IAAEI;IAAQC;IAAKJ;IAAMC,OAAOI,OAAOC,KAAKL,KAAAA,EAAOM,SAAS,IAAI,IAAIF,OAAOG,QAAQP,KAAAA,EAAOQ,IAAI,CAAC,CAACC,GAAGC,CAAAA,MAAO,GAAGD,KAAKC,GAAG,EAAEC,KAAK,GAAA,MAAS;IAAIC,QAAQX;EAAU;AAChK;AAHgBJ;AAKT,IAAMgB,QAAQ,2BAAIC,SAAwB;AAC/C,QAAMC,MAAM,CAAC;AACb,aAAWC,KAAKF,MAAM;AACpB,UAAM,EAAEG,MAAMlB,MAAMC,OAAOY,OAAM,IAAKI;AACtCD,QAAIE,QAAQ;MAAElB;MAAMC;MAAOY;IAAO;EACpC;AAEA,SAAOG;AACT,GARqB;AAYd,SAASG,UAAUC,UAA0G;AAElI,SAAO,CAACrB,KAAUsB,WAAgC;AAChD,UAAM,EAAEjB,KAAKS,QAAQZ,OAAOD,MAAMG,OAAM,IAAKL,MAAMC,GAAAA;AACnD,QAAI,CAACI,QAAQ;AACXmB,cAAQC,KAAK,oDAAA;AACb;IACF;AAEA,UAAMP,MAAM;MAAC,GAAGZ,MAAMS,SAASZ;;AAC/BD,YAAQgB,IAAIQ,KAAKxB,IAAAA;AACjBqB,cAAUL,IAAIQ,KAAKH,MAAAA;AAEnB,WAAOD,SAASjB,QAAO,GAAIa,GAAAA;EAC7B;AACF;AAfgBG;AAiBT,SAASM,eAAeL,UAAyBM,MAAM,sBAA2H;AAEvL,SAAO,CAACX,MAAqBM,WAAgC;AAC3D,WAAOD,SAASO,KAAKD,KAAKZ,MAAAA,GAASC,IAAAA,GAAOM,MAAAA;EAC5C;AACF;AALgBI;AAOT,SAASG,QAAiBC,MAAkC;AACjE,SAAO,OAAOA,SAAS,YAAaA,KAAaC;AACnD;AAFgBF;","names":["toReq","arg","body","query","realParam","method","url","Object","keys","length","entries","map","k","v","join","params","merge","args","ret","i","name","createReq","instance","config","console","warn","push","createMergeReq","key","post","isError","data","error"]}

package/dist/client/index.mjs

@@ -0,0 +1,61 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/client/index.ts
+function toReq(arg) {
+  const { body, query, realParam, method, url } = arg;
+  return {
+    method,
+    url,
+    body,
+    query: Object.keys(query).length > 0 ? `?${Object.entries(query).map(([k, v]) => `${k}=${v}`).join("&")}` : "",
+    params: realParam
+  };
+}
+__name(toReq, "toReq");
+var merge = /* @__PURE__ */ __name((...args) => {
+  const ret = {};
+  for (const i of args) {
+    const { name, body, query, params } = i;
+    ret[name] = {
+      body,
+      query,
+      params
+    };
+  }
+  return ret;
+}, "merge");
+function createReq(instance) {
+  return (arg, config) => {
+    const { url, params, query, body, method } = toReq(arg);
+    if (!method) {
+      console.warn("methods without route decorator won't send request");
+      return;
+    }
+    const ret = [
+      `${url}${params}${query}`
+    ];
+    body && ret.push(body);
+    config && ret.push(config);
+    return instance[method](...ret);
+  };
+}
+__name(createReq, "createReq");
+function createMergeReq(instance, key = "/__PHECDA_SERVER__") {
+  return (args, config) => {
+    return instance.post(key, merge(...args), config);
+  };
+}
+__name(createMergeReq, "createMergeReq");
+function isError(data) {
+  return typeof data === "object" && data.error;
+}
+__name(isError, "isError");
+export {
+  createMergeReq,
+  createReq,
+  isError,
+  merge,
+  toReq
+};
+//# sourceMappingURL=index.mjs.map

package/dist/client/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/client/index.ts"],"sourcesContent":["import type { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios'\nimport type { PError, RequestType, ResOrErr } from '../types'\ninterface RequestArgs {\n  body: Record<string, any>\n  query: Record<string, string>\n  params: Record<string, string>\n  realParam: string\n  method: RequestType\n  url: string\n  name: string\n}\ntype MergedReqArg = Pick<RequestArgs, 'body' | 'query' | 'params'>\nexport function toReq(arg: RequestArgs) {\n  const { body, query, realParam, method, url } = arg\n  return { method, url, body, query: Object.keys(query).length > 0 ? `?${Object.entries(query).map(([k, v]) => `${k}=${v}`).join('&')}` : '', params: realParam }\n}\n\nexport const merge = (...args: RequestArgs[]) => {\n  const ret = {} as Record<string, MergedReqArg>\n  for (const i of args) {\n    const { name, body, query, params } = i\n    ret[name] = { body, query, params }\n  }\n\n  return ret\n}\n\nexport type RequestMethod = <F extends (...args: any[]) => any >(fn: F, args: Parameters<F>) => Promise<ReturnType<F>>\n\nexport function createReq(instance: AxiosInstance): <R>(arg: R, config?: AxiosRequestConfig) => Promise<AxiosResponse<Awaited<R>> > {\n  // @ts-expect-error methods without route decorator won't send request\n  return (arg: any, config?: AxiosRequestConfig) => {\n    const { url, params, query, body, method } = toReq(arg as RequestArgs)\n    if (!method) {\n      console.warn('methods without route decorator won\\'t send request')\n      return\n    }\n\n    const ret = [`${url}${params}${query}`] as any[]\n    body && ret.push(body)\n    config && ret.push(config)\n    // @ts-expect-error misdirction\n    return instance[method](...ret)\n  }\n}\n\nexport function createMergeReq(instance: AxiosInstance, key = '/__PHECDA_SERVER__'): < R extends unknown[]>(args: R, config?: AxiosRequestConfig) => Promise<AxiosResponse<ResOrErr<R>>> {\n  // @ts-expect-error misdirction\n  return (args: RequestArgs[], config?: AxiosRequestConfig) => {\n    return instance.post(key, merge(...args), config)\n  }\n}\n\nexport function isError<T = any>(data: T | PError): data is PError {\n  return typeof data === 'object' && (data as any).error\n}\n"],"mappings":";;;;AAYO,SAASA,MAAMC,KAAkB;AACtC,QAAM,EAAEC,MAAMC,OAAOC,WAAWC,QAAQC,IAAG,IAAKL;AAChD,SAAO;IAAEI;IAAQC;IAAKJ;IAAMC,OAAOI,OAAOC,KAAKL,KAAAA,EAAOM,SAAS,IAAI,IAAIF,OAAOG,QAAQP,KAAAA,EAAOQ,IAAI,CAAC,CAACC,GAAGC,CAAAA,MAAO,GAAGD,KAAKC,GAAG,EAAEC,KAAK,GAAA,MAAS;IAAIC,QAAQX;EAAU;AAChK;AAHgBJ;AAKT,IAAMgB,QAAQ,2BAAIC,SAAwB;AAC/C,QAAMC,MAAM,CAAC;AACb,aAAWC,KAAKF,MAAM;AACpB,UAAM,EAAEG,MAAMlB,MAAMC,OAAOY,OAAM,IAAKI;AACtCD,QAAIE,QAAQ;MAAElB;MAAMC;MAAOY;IAAO;EACpC;AAEA,SAAOG;AACT,GARqB;AAYd,SAASG,UAAUC,UAA0G;AAElI,SAAO,CAACrB,KAAUsB,WAAgC;AAChD,UAAM,EAAEjB,KAAKS,QAAQZ,OAAOD,MAAMG,OAAM,IAAKL,MAAMC,GAAAA;AACnD,QAAI,CAACI,QAAQ;AACXmB,cAAQC,KAAK,oDAAA;AACb;IACF;AAEA,UAAMP,MAAM;MAAC,GAAGZ,MAAMS,SAASZ;;AAC/BD,YAAQgB,IAAIQ,KAAKxB,IAAAA;AACjBqB,cAAUL,IAAIQ,KAAKH,MAAAA;AAEnB,WAAOD,SAASjB,QAAO,GAAIa,GAAAA;EAC7B;AACF;AAfgBG;AAiBT,SAASM,eAAeL,UAAyBM,MAAM,sBAA2H;AAEvL,SAAO,CAACX,MAAqBM,WAAgC;AAC3D,WAAOD,SAASO,KAAKD,KAAKZ,MAAAA,GAASC,IAAAA,GAAOM,MAAAA;EAC5C;AACF;AALgBI;AAOT,SAASG,QAAiBC,MAAkC;AACjE,SAAO,OAAOA,SAAS,YAAaA,KAAaC;AACnD;AAFgBF;","names":["toReq","arg","body","query","realParam","method","url","Object","keys","length","entries","map","k","v","join","params","merge","args","ret","i","name","createReq","instance","config","console","warn","push","createMergeReq","key","post","isError","data","error"]}

package/dist/index.d.ts

@@ -0,0 +1,116 @@
+import { S as ServerMeta, R as RequestType, C as Construct } from './types-6e2842b3.js';
+export { M as MergeType, P as PError, a as ResOrErr, T as Transform, U as UnWrap } from './types-6e2842b3.js';
+import { Express } from 'express';
+import { PluginOption } from 'vite';
+
+declare class Pmeta {
+    data: ServerMeta;
+    reflect: any[];
+    constructor(data: ServerMeta, reflect: any[]);
+}
+
+interface Ppipe {
+    transform(args: {
+        arg: any;
+        validate?: boolean;
+    }[], reflect: any[]): Promise<any[]>;
+}
+declare const defaultPipe: Ppipe;
+
+declare class Pserver {
+    key: string;
+    meta: Pmeta;
+    method: string;
+    params: string[];
+    static pipe: Ppipe;
+    static guardsRecord: Record<string, (...params: any) => boolean>;
+    static middlewareRecord: Record<string, (...params: any) => boolean>;
+    static interceptorsRecord: Record<string, (...params: any) => any | ((...params: any) => any)>;
+    static serverRecord: Record<string, Pserver>;
+    constructor(key: string, meta: Pmeta);
+    static registerGuard(key: string, handler: any): void;
+    static registerInterceptor(key: string, handler: any): void;
+    useGuard(req: any, guards: string[]): Promise<void>;
+    useInterceptor(req: any, interceptors: string[]): Promise<any[]>;
+    usePost(ret: any, cbs: ((...params: any[]) => any)[]): Promise<any>;
+    usePipe(args: {
+        arg: any;
+        validate?: boolean;
+    }[], reflect: any[]): Promise<any[]>;
+    methodToHandler(method: (...params: any[]) => any): (req: any) => Promise<any>;
+}
+declare function addGuard(key: string, handler: (...params: any) => boolean): void;
+declare function addInterceptor(key: string, handler: (...params: any) => any | ((...params: any) => any)): void;
+declare function usePipe(pipe: Ppipe): void;
+
+declare class Pcompiler {
+    content: string;
+    classMap: Record<string, {
+        [key: string]: string;
+    }>;
+    constructor();
+    getContent(): string;
+    addMethod(className: string, methodName: string, route?: string, requestType?: RequestType | '', params?: {
+        type: string;
+        key: string;
+        index: number;
+    }[]): void;
+}
+
+declare function bindApp(app: Express, { meta, moduleMap }: {
+    meta: Pmeta[];
+    moduleMap: any;
+}, key?: string): void;
+
+declare function Factory<T>(Modules: Construct<T>[]): {
+    moduleMap: Map<string, any>;
+    meta: Pmeta[];
+};
+
+declare function BaseParam(type: string, key: string, validate?: boolean): any;
+declare function Body(key: string, validate?: boolean): any;
+declare function Query(key: string, validate?: boolean): any;
+declare function Param(key: string, validate?: boolean): any;
+
+declare function Route(route: string, type?: string): any;
+declare function Get(route: string): any;
+declare function Post(route: string): any;
+declare function Put(route: string): any;
+declare function Delete(route: string): any;
+declare function Controller(route: string): any;
+
+declare function Inject(): void;
+declare function Header(name: string, value: string): (target: any, k: PropertyKey) => void;
+
+declare function Server(localPath: string): PluginOption;
+
+declare class HttpException extends Error {
+    message: string;
+    status: number;
+    description: string;
+    constructor(message: string, status: number, description?: string);
+    get data(): {
+        message: string;
+        description: string;
+        status: number;
+        error: boolean;
+    };
+}
+
+declare class UndefinedException extends HttpException {
+    constructor(message: string);
+}
+
+declare class ValidateException extends HttpException {
+    constructor(message: string);
+}
+
+declare class ForbiddenException extends HttpException {
+    constructor(message: string);
+}
+
+declare class BadRequestException extends HttpException {
+    constructor(message: string);
+}
+
+export { BadRequestException, BaseParam, Body, Construct, Controller, Delete, Factory, ForbiddenException, Get, Header, HttpException, Inject, Param, Pcompiler, Pmeta, Post, Ppipe, Pserver, Put, Query, RequestType, Route, Server, ServerMeta, UndefinedException, ValidateException, addGuard, addInterceptor, bindApp, defaultPipe, usePipe };