@akanjs/signal 0.0.4

package/src/signalDecorators.js

@@ -0,0 +1,571 @@
+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;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+var signalDecorators_exports = {};
+__export(signalDecorators_exports, {
+  Access: () => Access,
+  Account: () => Account,
+  Arg: () => Arg,
+  DbSignal: () => DbSignal,
+  Job: () => Job,
+  LogSignal: () => LogSignal,
+  Me: () => Me,
+  Message: () => Message,
+  Mutation: () => Mutation,
+  Parent: () => Parent,
+  Process: () => Process,
+  Pubsub: () => Pubsub,
+  Query: () => Query,
+  Req: () => Req,
+  Res: () => Res,
+  ResolveField: () => ResolveField,
+  Self: () => Self,
+  Signal: () => Signal,
+  SignalStorage: () => SignalStorage,
+  UserIp: () => UserIp,
+  Ws: () => Ws,
+  argTypes: () => argTypes,
+  copySignal: () => copySignal,
+  createArgMetaDecorator: () => createArgMetaDecorator,
+  defaultAccount: () => defaultAccount,
+  done: () => done,
+  emit: () => emit,
+  endpointTypes: () => endpointTypes,
+  getAllSignalRefs: () => getAllSignalRefs,
+  getArgMetas: () => getArgMetas,
+  getControllerPath: () => getControllerPath,
+  getControllerPrefix: () => getControllerPrefix,
+  getGqlMeta: () => getGqlMeta,
+  getGqlMetaMapOnPrototype: () => getGqlMetaMapOnPrototype,
+  getGqlMetas: () => getGqlMetas,
+  getResolveFieldMetas: () => getResolveFieldMetas,
+  getSigMeta: () => getSigMeta,
+  getSignalRefsOnStorage: () => getSignalRefsOnStorage,
+  guardTypes: () => guardTypes,
+  internalArgTypes: () => internalArgTypes,
+  resolve: () => resolve,
+  roleTypes: () => roleTypes,
+  setArgMetas: () => setArgMetas,
+  setGqlMetaMapOnPrototype: () => setGqlMetaMapOnPrototype,
+  signalTypes: () => signalTypes,
+  ssoTypes: () => ssoTypes,
+  subscribe: () => subscribe
+});
+module.exports = __toCommonJS(signalDecorators_exports);
+var import_reflect_metadata = require("reflect-metadata");
+var import_base = require("@akanjs/base");
+var import_common = require("@akanjs/common");
+var import_constant = require("@akanjs/constant");
+var import_gql = require("./gql");
+const ssoTypes = ["github", "google", "facebook", "apple", "naver", "kakao"];
+class SignalStorage {
+}
+const getAllSignalRefs = () => {
+  const signalNames = Reflect.getOwnMetadataKeys(SignalStorage.prototype);
+  const sigRefs = signalNames?.reduce((acc, signalName) => [...acc, ...getSignalRefsOnStorage(signalName)], []) ?? [];
+  return sigRefs;
+};
+const getSignalRefsOnStorage = (refName) => {
+  const sigRefs = Reflect.getMetadata(refName, SignalStorage.prototype);
+  return sigRefs ?? [];
+};
+const setSignalRefOnStorage = (refName, signalRef) => {
+  Reflect.defineMetadata(refName, [...getSignalRefsOnStorage(refName), signalRef], SignalStorage.prototype);
+};
+const resolve = (data) => data;
+const emit = (data) => data;
+const done = (data) => data;
+const subscribe = () => void 0;
+const signalTypes = ["graphql", "restapi"];
+const endpointTypes = ["Query", "Mutation", "Message", "Pubsub", "Process"];
+const guardTypes = ["Public", "None", "User", "Admin", "SuperAdmin", "Every", "Owner"];
+const roleTypes = ["Public", "User", "Admin", "SuperAdmin"];
+const argTypes = ["Body", "Param", "Query", "Upload", "Msg", "Room"];
+const internalArgTypes = [
+  "Account",
+  "Me",
+  "Self",
+  "UserIp",
+  "Access",
+  "Parent",
+  "Req",
+  "Res",
+  "Ws",
+  "Job"
+];
+const getDefaultArg = (argRef) => {
+  const [modelRef, arrDepth] = (0, import_base.getNonArrayModel)(argRef);
+  if (arrDepth)
+    return [];
+  const scalarArg = import_base.scalarArgMap.get(modelRef);
+  if (scalarArg)
+    return scalarArg;
+  else
+    return {};
+};
+function Signal(returnsOrObj) {
+  const returns = typeof returnsOrObj === "function" ? returnsOrObj : void 0;
+  const prefix = typeof returnsOrObj === "object" ? returnsOrObj.prefix : void 0;
+  return function(target) {
+    if (returns) {
+      const modelRef = returns();
+      const classMeta = (0, import_constant.getClassMeta)(modelRef);
+      const gqlMetas = getGqlMetas(target);
+      const modelName = (0, import_common.lowerlize)(classMeta.refName);
+      const listName = `${modelName}ListIn`;
+      const slices = [
+        { refName: modelName, sliceName: modelName, argLength: 1, defaultArgs: [{}] },
+        ...gqlMetas.filter((gqlMeta) => {
+          const name = gqlMeta.signalOption.name ?? gqlMeta.key;
+          if (!name.includes(listName))
+            return false;
+          const [retRef, arrDepth] = (0, import_base.getNonArrayModel)(gqlMeta.returns());
+          return retRef.prototype === modelRef.prototype && arrDepth === 1;
+        }).map((gqlMeta) => {
+          const name = gqlMeta.signalOption.name ?? gqlMeta.key;
+          const sliceName = name.replace(listName, `${modelName}In`);
+          const [argMetas] = getArgMetas(target, gqlMeta.key);
+          const skipIdx = argMetas.findIndex((argMeta) => argMeta.name === "skip");
+          if (skipIdx === -1)
+            throw new Error(`Invalid Args for ${sliceName}`);
+          const argLength = skipIdx;
+          const queryArgRefs = argMetas.slice(0, skipIdx).map((argMeta) => argMeta.returns());
+          const defaultArgs = queryArgRefs.map(
+            (queryArgRef, idx) => argMetas[idx].argsOption.nullable ? null : getDefaultArg(queryArgRef)
+          );
+          return { refName: modelName, sliceName, argLength, defaultArgs };
+        })
+      ];
+      setSigMeta(target, { returns, prefix, slices, refName: modelName });
+      setSignalRefOnStorage(modelName, target);
+    } else {
+      const refName = typeof returnsOrObj === "object" ? (0, import_common.lowerlize)(returnsOrObj.name) : void 0;
+      if (!refName)
+        throw new Error("Signal name is required");
+      setSigMeta(target, { returns, prefix, slices: [], refName });
+      setSignalRefOnStorage(refName, target);
+    }
+  };
+}
+const createArgMetaDecorator = (type) => {
+  return function(option = {}) {
+    return function(prototype, key, idx) {
+      const argMetas = getArgMetasOnPrototype(prototype, key);
+      argMetas[idx] = { key, idx, type, option };
+      setArgMetasOnPrototype(prototype, key, argMetas);
+    };
+  };
+};
+const Account = createArgMetaDecorator("Account");
+const defaultAccount = {
+  __InternalArg__: "Account",
+  appName: import_base.baseEnv.appName,
+  environment: import_base.baseEnv.environment
+};
+const Self = createArgMetaDecorator("Self");
+const Me = createArgMetaDecorator("Me");
+const UserIp = createArgMetaDecorator("UserIp");
+const Access = createArgMetaDecorator("Access");
+const Req = createArgMetaDecorator("Req");
+const Res = createArgMetaDecorator("Res");
+const Ws = createArgMetaDecorator("Ws");
+const Job = createArgMetaDecorator("Job");
+const getQuery = (allow) => function(returns, signalOption = {}, guards = []) {
+  return (prototype, key, descriptor) => {
+    const metadataMap = getGqlMetaMapOnPrototype(prototype);
+    metadataMap.set(key, {
+      returns,
+      signalOption,
+      key,
+      descriptor,
+      guards: [allow, ...guards],
+      type: "Query"
+    });
+    setGqlMetaMapOnPrototype(prototype, metadataMap);
+  };
+};
+const getMutation = (allow) => function(returns, signalOption = {}, guards = []) {
+  return (prototype, key, descriptor) => {
+    const metadataMap = getGqlMetaMapOnPrototype(prototype);
+    metadataMap.set(key, {
+      returns,
+      signalOption,
+      key,
+      descriptor,
+      guards: [allow, ...guards],
+      type: "Mutation"
+    });
+    setGqlMetaMapOnPrototype(prototype, metadataMap);
+  };
+};
+const getMessage = (allow) => function(returns, signalOption = {}, guards = []) {
+  return (prototype, key, descriptor) => {
+    const metadataMap = getGqlMetaMapOnPrototype(prototype);
+    metadataMap.set(key, {
+      returns,
+      signalOption,
+      key,
+      descriptor,
+      guards: [allow, ...guards],
+      type: "Message"
+    });
+    setGqlMetaMapOnPrototype(prototype, metadataMap);
+  };
+};
+const getPubsub = (allow) => function(returns, signalOption = {}, guards = []) {
+  return (prototype, key, descriptor) => {
+    const metadataMap = getGqlMetaMapOnPrototype(prototype);
+    metadataMap.set(key, {
+      returns,
+      signalOption,
+      key,
+      descriptor,
+      guards: [allow, ...guards],
+      type: "Pubsub"
+    });
+    setGqlMetaMapOnPrototype(prototype, metadataMap);
+  };
+};
+const getProcess = (serverType) => function(returns, signalOption = {}) {
+  return (prototype, key, descriptor) => {
+    const metadataMap = getGqlMetaMapOnPrototype(prototype);
+    metadataMap.set(key, {
+      returns,
+      signalOption: { ...signalOption, serverType: (0, import_common.lowerlize)(serverType) },
+      key,
+      descriptor,
+      guards: ["None"],
+      type: "Process"
+    });
+    setGqlMetaMapOnPrototype(prototype, metadataMap);
+  };
+};
+const Query = {
+  Public: getQuery("Public"),
+  Every: getQuery("Every"),
+  Admin: getQuery("Admin"),
+  User: getQuery("User"),
+  SuperAdmin: getQuery("SuperAdmin"),
+  None: getQuery("None"),
+  Owner: getQuery("Owner")
+};
+const Mutation = {
+  Public: getMutation("Public"),
+  Every: getMutation("Every"),
+  Admin: getMutation("Admin"),
+  User: getMutation("User"),
+  SuperAdmin: getMutation("SuperAdmin"),
+  None: getMutation("None"),
+  Owner: getMutation("Owner")
+};
+const Message = {
+  Public: getMessage("Public"),
+  Every: getMessage("Every"),
+  Admin: getMessage("Admin"),
+  User: getMessage("User"),
+  SuperAdmin: getMessage("SuperAdmin"),
+  None: getMessage("None"),
+  Owner: getMessage("Owner")
+};
+const Pubsub = {
+  Public: getPubsub("Public"),
+  Every: getPubsub("Every"),
+  Admin: getPubsub("Admin"),
+  User: getPubsub("User"),
+  SuperAdmin: getPubsub("SuperAdmin"),
+  None: getPubsub("None"),
+  Owner: getPubsub("Owner")
+};
+const Process = {
+  Federation: getProcess("Federation"),
+  Batch: getProcess("Batch"),
+  All: getProcess("All")
+};
+function ResolveField(returns, argsOption = {}) {
+  return function(target, key, descriptor) {
+    const metadataMap = getResolveFieldMetaMapOnPrototype(target);
+    metadataMap.set(key, { returns, argsOption, key, descriptor });
+    Reflect.defineMetadata("resolveField", metadataMap, target);
+  };
+}
+const getArg = (type) => function(name, returns, argsOption = {}) {
+  return function(prototype, key, idx) {
+    const argMetas = getArgMetasOnPrototype(prototype, key);
+    argMetas[idx] = { name, returns, argsOption, key, idx, type };
+    setArgMetasOnPrototype(prototype, key, argMetas);
+  };
+};
+const Arg = {
+  Body: getArg("Body"),
+  Param: getArg("Param"),
+  Query: getArg("Query"),
+  Upload: getArg("Upload"),
+  Msg: getArg("Msg"),
+  Room: getArg("Room")
+};
+function Parent() {
+  return function(prototype, key, idx) {
+    const argMetas = getArgMetasOnPrototype(prototype, key);
+    argMetas[idx] = { key, idx, type: "Parent" };
+    setArgMetasOnPrototype(prototype, key, argMetas);
+  };
+}
+function LogSignal(srv) {
+  class BaseSignal {
+  }
+  return BaseSignal;
+}
+function DbSignal(constant, srv, option) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const meta = (0, import_constant.getClassMeta)(constant.Full);
+  const serviceName = `${(0, import_common.lowerlize)(meta.refName)}Service`;
+  const [modelName, className] = [(0, import_common.lowerlize)(meta.refName), (0, import_common.capitalize)(meta.refName)];
+  const names = {
+    modelId: `${modelName}Id`,
+    model: modelName,
+    lightModel: `light${className}`,
+    modelList: `${modelName}List`,
+    modelInsight: `${modelName}Insight`,
+    modelExists: `${modelName}Exists`,
+    getModel: `get${className}`,
+    createModel: `create${className}`,
+    updateModel: `update${className}`,
+    removeModel: `remove${className}`
+  };
+  class BaseSignal {
+    async [_a = names.lightModel](id) {
+      const service = this[serviceName];
+      const model = await service[names.getModel](id);
+      return resolve(model);
+    }
+    async [_b = names.model](id) {
+      const service = this[serviceName];
+      const model = await service[names.getModel](id);
+      return resolve(model);
+    }
+    async [_c = names.modelList](query, skip, limit, sort) {
+      const service = this[serviceName];
+      const models = query?.$search ? await service.__searchDocs(query.$search, { skip, limit, sort }) : await service.__list(query, { skip, limit, sort });
+      return resolve(models);
+    }
+    async [_d = names.modelInsight](query) {
+      const service = this[serviceName];
+      const insight = query.$search ? { ...(0, import_gql.makeDefault)(constant.Insight), count: await service.__searchCount(query.$search) } : await service.__insight(query);
+      return resolve(insight);
+    }
+    async [_e = names.modelExists](query) {
+      const service = this[serviceName];
+      const exists = await service.__exists(query);
+      return resolve(exists);
+    }
+    async [_f = names.createModel](data) {
+      const service = this[serviceName];
+      const model = await service[names.createModel](data);
+      return resolve(model);
+    }
+    async [_g = names.updateModel](id, data) {
+      const service = this[serviceName];
+      const model = await service[names.updateModel](id, data);
+      return resolve(model);
+    }
+    async [_h = names.removeModel](id) {
+      const service = this[serviceName];
+      const model = await service[names.removeModel](id);
+      return resolve(model);
+    }
+  }
+  __decorateClass([
+    option.guards.get(() => constant.Light),
+    __decorateParam(0, Arg.Param(names.modelId, () => import_base.ID))
+  ], BaseSignal.prototype, _a, 1);
+  __decorateClass([
+    option.guards.get(() => constant.Full),
+    __decorateParam(0, Arg.Param(names.modelId, () => import_base.ID))
+  ], BaseSignal.prototype, _b, 1);
+  __decorateClass([
+    Query.Admin(() => [constant.Full]),
+    __decorateParam(0, Arg.Query("query", () => import_base.JSON)),
+    __decorateParam(1, Arg.Query("skip", () => import_base.Int, { nullable: true, example: 0 })),
+    __decorateParam(2, Arg.Query("limit", () => import_base.Int, { nullable: true, example: 20 })),
+    __decorateParam(3, Arg.Query("sort", () => String, { nullable: true, example: "latest" }))
+  ], BaseSignal.prototype, _c, 1);
+  __decorateClass([
+    Query.Admin(() => constant.Insight),
+    __decorateParam(0, Arg.Query("query", () => import_base.JSON))
+  ], BaseSignal.prototype, _d, 1);
+  __decorateClass([
+    Query.Admin(() => Boolean),
+    __decorateParam(0, Arg.Query("query", () => import_base.JSON))
+  ], BaseSignal.prototype, _e, 1);
+  __decorateClass([
+    option.guards.cru(() => constant.Full),
+    __decorateParam(0, Arg.Body(`data`, () => constant.Input))
+  ], BaseSignal.prototype, _f, 1);
+  __decorateClass([
+    option.guards.cru(() => constant.Full),
+    __decorateParam(0, Arg.Param(names.modelId, () => import_base.ID)),
+    __decorateParam(1, Arg.Body("data", () => constant.Input))
+  ], BaseSignal.prototype, _g, 1);
+  __decorateClass([
+    option.guards.cru(() => constant.Full, { partial: ["status", "removedAt"] }),
+    __decorateParam(0, Arg.Param(names.modelId, () => import_base.ID))
+  ], BaseSignal.prototype, _h, 1);
+  return BaseSignal;
+}
+const getSigMeta = (sigRef) => {
+  const sigMeta = Reflect.getMetadata("signal", sigRef.prototype);
+  if (!sigMeta)
+    throw new Error(`No SignalMeta found for ${sigRef.name}`);
+  return sigMeta;
+};
+const setSigMeta = (sigRef, sigMeta) => {
+  Reflect.defineMetadata("signal", sigMeta, sigRef.prototype);
+};
+const getGqlMeta = (sigRef, key) => {
+  const gqlMetaMap = Reflect.getMetadata("gql", sigRef.prototype);
+  if (!gqlMetaMap)
+    throw new Error(`No GqlMeta found for ${sigRef.name}`);
+  const gqlMeta = gqlMetaMap.get(key);
+  if (!gqlMeta)
+    throw new Error(`No GqlMeta found for ${key}`);
+  return gqlMeta;
+};
+const getGqlMetaMapOnPrototype = (prototype) => {
+  const gqlMetaMap = Reflect.getMetadata("gql", prototype);
+  return gqlMetaMap ?? /* @__PURE__ */ new Map();
+};
+const getGqlMetas = (sigRef) => {
+  const gqlMetaMap = Reflect.getMetadata("gql", sigRef.prototype);
+  return gqlMetaMap ? [...gqlMetaMap.values()] : [];
+};
+const setGqlMetaMapOnPrototype = (prototype, gqlMetaMap) => {
+  Reflect.defineMetadata("gql", gqlMetaMap, prototype);
+};
+const getArgMetas = (sigRef, key) => {
+  const metas = Reflect.getMetadata("args", sigRef.prototype, key) ?? [];
+  const argMetas = metas.filter((meta) => !!meta.returns);
+  const internalArgMetas = metas.filter((meta) => !meta.returns);
+  return [argMetas, internalArgMetas];
+};
+const getArgMetasOnPrototype = (prototype, key) => {
+  return Reflect.getMetadata("args", prototype, key) ?? [];
+};
+const setArgMetas = (sigRef, key, argMetas, internalArgMetas) => {
+  Reflect.defineMetadata("args", [...argMetas, ...internalArgMetas], sigRef.prototype, key);
+};
+const setArgMetasOnPrototype = (prototype, key, argMetas) => {
+  Reflect.defineMetadata("args", argMetas, prototype, key);
+};
+const getResolveFieldMetaMapOnPrototype = (prototype) => {
+  const resolveFieldMetaMap = Reflect.getMetadata("resolveField", prototype);
+  return resolveFieldMetaMap ?? /* @__PURE__ */ new Map();
+};
+const getResolveFieldMetas = (sigRef) => {
+  const resolveFieldMetaMap = Reflect.getMetadata("resolveField", sigRef.prototype);
+  return resolveFieldMetaMap ? [...resolveFieldMetaMap.values()] : [];
+};
+const setResolveFieldMetaMapOnPrototype = (prototype, resolveFieldMetaMap) => {
+  Reflect.defineMetadata("resolveField", resolveFieldMetaMap, prototype);
+};
+const getControllerPrefix = (sigMeta) => {
+  return sigMeta.returns ? (0, import_common.lowerlize)((0, import_constant.getClassMeta)(sigMeta.returns()).refName) : sigMeta.prefix;
+};
+const getControllerPath = (gqlMeta, paramArgMetas) => {
+  return gqlMeta.signalOption.path ?? [gqlMeta.signalOption.name ?? gqlMeta.key, ...paramArgMetas.map((argMeta) => `:${argMeta.name}`)].join("/");
+};
+const copySignal = (sigRef) => {
+  class CopiedSignal {
+  }
+  (0, import_common.applyMixins)(CopiedSignal, [sigRef]);
+  const sigMeta = getSigMeta(sigRef);
+  setSigMeta(CopiedSignal, sigMeta);
+  const gqlMetaMap = getGqlMetaMapOnPrototype(sigRef.prototype);
+  setGqlMetaMapOnPrototype(CopiedSignal.prototype, new Map(gqlMetaMap));
+  const resolveFieldMetaMap = getResolveFieldMetaMapOnPrototype(sigRef.prototype);
+  setResolveFieldMetaMapOnPrototype(CopiedSignal.prototype, new Map(resolveFieldMetaMap));
+  for (const endpointMeta of [...gqlMetaMap.values(), ...resolveFieldMetaMap.values()]) {
+    const argMetas = getArgMetasOnPrototype(sigRef.prototype, endpointMeta.key);
+    setArgMetasOnPrototype(CopiedSignal.prototype, endpointMeta.key, [...argMetas]);
+    const paramtypes = Reflect.getMetadata(
+      "design:paramtypes",
+      sigRef.prototype,
+      endpointMeta.key
+    );
+    Reflect.defineMetadata("design:paramtypes", [...paramtypes], CopiedSignal.prototype, endpointMeta.key);
+  }
+  return CopiedSignal;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Access,
+  Account,
+  Arg,
+  DbSignal,
+  Job,
+  LogSignal,
+  Me,
+  Message,
+  Mutation,
+  Parent,
+  Process,
+  Pubsub,
+  Query,
+  Req,
+  Res,
+  ResolveField,
+  Self,
+  Signal,
+  SignalStorage,
+  UserIp,
+  Ws,
+  argTypes,
+  copySignal,
+  createArgMetaDecorator,
+  defaultAccount,
+  done,
+  emit,
+  endpointTypes,
+  getAllSignalRefs,
+  getArgMetas,
+  getControllerPath,
+  getControllerPrefix,
+  getGqlMeta,
+  getGqlMetaMapOnPrototype,
+  getGqlMetas,
+  getResolveFieldMetas,
+  getSigMeta,
+  getSignalRefsOnStorage,
+  guardTypes,
+  internalArgTypes,
+  resolve,
+  roleTypes,
+  setArgMetas,
+  setGqlMetaMapOnPrototype,
+  signalTypes,
+  ssoTypes,
+  subscribe
+});