@akanjs/signal 0.0.4

package/src/immerify.d.ts

@@ -0,0 +1,2 @@
+import { type Type } from "@akanjs/base";
+export declare const immerify: <T extends object | object[]>(modelRef: Type, objOrArr: T) => T;

package/src/immerify.js

@@ -0,0 +1,39 @@
+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 immerify_exports = {};
+__export(immerify_exports, {
+  immerify: () => immerify
+});
+module.exports = __toCommonJS(immerify_exports);
+var import_constant = require("@akanjs/constant");
+var import_immer = require("immer");
+const immerify = (modelRef, objOrArr) => {
+  if (Array.isArray(objOrArr))
+    return objOrArr.map((val) => immerify(modelRef, val));
+  const fieldMetas = (0, import_constant.getFieldMetas)(modelRef);
+  const immeredObj = Object.assign({}, objOrArr, { [import_immer.immerable]: true });
+  fieldMetas.forEach((fieldMeta) => {
+    if (fieldMeta.isScalar && fieldMeta.isClass && !!objOrArr[fieldMeta.key])
+      immeredObj[fieldMeta.key] = immerify(fieldMeta.modelRef, objOrArr[fieldMeta.key]);
+  });
+  return immeredObj;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  immerify
+});

package/src/index.d.ts

@@ -0,0 +1,5 @@
+export { type Client, client } from "./client";
+export { immerify } from "./immerify";
+export * from "./gql";
+export * from "./signalDecorators";
+export * from "./doc";

package/src/index.js

@@ -0,0 +1,37 @@
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+__export(src_exports, {
+  client: () => import_client.client,
+  immerify: () => import_immerify.immerify
+});
+module.exports = __toCommonJS(src_exports);
+var import_client = require("./client");
+var import_immerify = require("./immerify");
+__reExport(src_exports, require("./gql"), module.exports);
+__reExport(src_exports, require("./signalDecorators"), module.exports);
+__reExport(src_exports, require("./doc"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  client,
+  immerify,
+  ...require("./gql"),
+  ...require("./signalDecorators"),
+  ...require("./doc")
+});

package/src/signalDecorators.d.ts

@@ -0,0 +1,295 @@
+import "reflect-metadata";
+import { BaseObject, Dayjs, Enum, Environment, SingleFieldType, Type } from "@akanjs/base";
+import { ConstantModel, DocumentModel, FilterType, GetActionObject, ReturnType, SortOf } from "@akanjs/constant";
+import type { Job as BullJob } from "bull";
+import type { Request as ExpressRequest, Response as ExpressResponse } from "express";
+import type { Socket } from "socket.io";
+export declare const ssoTypes: readonly ["github", "google", "facebook", "apple", "naver", "kakao"];
+export type SSOType = (typeof ssoTypes)[number];
+export declare class SignalStorage {
+}
+export declare const getAllSignalRefs: () => Type[];
+export declare const getSignalRefsOnStorage: (refName: string) => Type[];
+export type Resolve<T> = T;
+export declare const resolve: <T>(data: any) => Resolve<T>;
+export declare const emit: <T>(data: any) => Resolve<T> & {
+    __Returns__: "Emit";
+};
+export declare const done: <T>(data: any) => Resolve<T> & {
+    __Returns__: "Done";
+};
+export declare const subscribe: <T>() => Resolve<T> & {
+    __Returns__: "Subscribe";
+};
+export interface SignalOption<Response = any> {
+    nullable?: boolean;
+    name?: string;
+    default?: boolean;
+    path?: string;
+    onlyFor?: "graphql" | "restapi";
+    sso?: SSOType;
+    serverType?: "federation" | "batch" | "all";
+    timeout?: number;
+    partial?: (keyof Response)[] | readonly (keyof Response)[];
+    cache?: number;
+}
+export interface ResolveFieldMeta {
+    returns: ReturnType;
+    argsOption: ArgsOption;
+    key: string;
+    descriptor: PropertyDescriptor;
+}
+export declare const signalTypes: readonly ["graphql", "restapi"];
+export type SignalType = (typeof signalTypes)[number];
+export declare const endpointTypes: readonly ["Query", "Mutation", "Message", "Pubsub", "Process"];
+export type EndpointType = (typeof endpointTypes)[number];
+export declare const guardTypes: readonly ["Public", "None", "User", "Admin", "SuperAdmin", "Every", "Owner"];
+export type GuardType = (typeof guardTypes)[number];
+export declare const roleTypes: readonly ["Public", "User", "Admin", "SuperAdmin"];
+export type RoleType = (typeof roleTypes)[number];
+export declare const argTypes: readonly ["Body", "Param", "Query", "Upload", "Msg", "Room"];
+export type ArgType = (typeof argTypes)[number];
+export declare const internalArgTypes: readonly ["Account", "Me", "Self", "UserIp", "Access", "Parent", "Req", "Res", "Ws", "Job"];
+export type InternalArgType = (typeof internalArgTypes)[number];
+export interface GqlMeta {
+    returns: (of?: any) => Type;
+    signalOption: SignalOption;
+    key: string;
+    descriptor: PropertyDescriptor;
+    guards: GuardType[];
+    type: EndpointType;
+}
+export interface ArgsOption {
+    nullable?: boolean;
+    example?: string | number | boolean | Dayjs;
+    enum?: Enum<string | number>;
+}
+export interface ArgMeta {
+    name: string;
+    returns: ReturnType;
+    argsOption: ArgsOption;
+    key: string;
+    idx: number;
+    type: ArgType;
+}
+export interface InternalArgMeta {
+    key: string;
+    idx: number;
+    type: InternalArgType;
+    option?: {
+        nullable?: boolean;
+    };
+}
+export interface SliceMeta {
+    refName: string;
+    sliceName: string;
+    argLength: number;
+    defaultArgs: any[];
+}
+export interface SignalMeta {
+    refName: string;
+    slices: SliceMeta[];
+    returns?: (of?: any) => Type;
+    prefix?: string;
+}
+interface SignalDecoratorInput {
+    name: string;
+    prefix?: string;
+}
+export declare function Signal(returnsOrObj: (() => Type) | SignalDecoratorInput): (target: Type) => void;
+export declare const createArgMetaDecorator: (type: InternalArgType) => (option?: {
+    nullable?: boolean;
+}) => (prototype: object, key: string, idx: number) => void;
+export declare const Account: (option?: {
+    nullable?: boolean;
+}) => (prototype: object, key: string, idx: number) => void;
+export type Account<AddData = unknown> = {
+    __InternalArg__: "Account";
+    self?: Self;
+    me?: Me;
+    appName: string;
+    environment: Environment;
+} & AddData;
+export declare const defaultAccount: Account;
+export declare const Self: (option?: {
+    nullable?: boolean;
+}) => (prototype: object, key: string, idx: number) => void;
+export interface Self {
+    __InternalArg__: "Self";
+    id: string;
+    nickname: string;
+    roles: string[];
+    image: {
+        url: string;
+        imageSize: [number, number];
+    } | null;
+    profileStatus: "active" | "prepare" | "applied" | "approved" | "reapplied" | "featured" | "reserved" | "rejected";
+    status: "prepare" | "active" | "restricted" | "dormant";
+    removedAt: Dayjs | null;
+}
+export declare const Me: (option?: {
+    nullable?: boolean;
+}) => (prototype: object, key: string, idx: number) => void;
+export interface Me {
+    __InternalArg__: "Me";
+    id: string;
+    accountId: string;
+    roles: string[];
+    status: "active";
+    removedAt: Dayjs | null;
+}
+export declare const UserIp: (option?: {
+    nullable?: boolean;
+}) => (prototype: object, key: string, idx: number) => void;
+export interface UserIp {
+    ip: string;
+    __InternalArg__: "UserIp";
+}
+export declare const Access: (option?: {
+    nullable?: boolean;
+}) => (prototype: object, key: string, idx: number) => void;
+export interface Access {
+    __InternalArg__: "Access";
+    period: number;
+    countryCode?: string;
+    countryName?: string;
+    city?: string;
+    postal?: number;
+    location?: {
+        type: "Point";
+        coordinates: [number, number];
+    };
+    ipv4?: string;
+    state?: string;
+    userAgent?: string;
+    at: Dayjs;
+}
+export declare const Req: (option?: {
+    nullable?: boolean;
+}) => (prototype: object, key: string, idx: number) => void;
+export type Req = {
+    __InternalArg__: "Req";
+    account: Account;
+    user: any;
+} & ExpressRequest;
+export declare const Res: (option?: {
+    nullable?: boolean;
+}) => (prototype: object, key: string, idx: number) => void;
+export type Res = {
+    __InternalArg__: "Res";
+} & ExpressResponse;
+export declare const Ws: (option?: {
+    nullable?: boolean;
+}) => (prototype: object, key: string, idx: number) => void;
+export type Ws = {
+    __InternalArg__: "Ws";
+} & {
+    socket: Socket;
+    subscribe: boolean;
+    onSubscribe: (handler: () => void | Promise<void>) => void;
+    onUnsubscribe: (handler: () => void | Promise<void>) => void;
+    onDisconnect: (handler: () => void | Promise<void>) => void;
+};
+export declare const Job: (option?: {
+    nullable?: boolean;
+}) => (prototype: object, key: string, idx: number) => void;
+export type Job = {
+    __InternalArg__: "Job";
+} & BullJob;
+type Guard = <Response extends SingleFieldType>(returns: ReturnType<Response>, signalOption?: SignalOption<UnType<Response>>, guards?: GuardType[]) => MethodDecorator;
+export declare const Query: {
+    Public: Guard;
+    Every: Guard;
+    Admin: Guard;
+    User: Guard;
+    SuperAdmin: Guard;
+    None: Guard;
+    Owner: Guard;
+};
+export declare const Mutation: {
+    Public: Guard;
+    Every: Guard;
+    Admin: Guard;
+    User: Guard;
+    SuperAdmin: Guard;
+    None: Guard;
+    Owner: Guard;
+};
+export declare const Message: {
+    Public: Guard;
+    Every: Guard;
+    Admin: Guard;
+    User: Guard;
+    SuperAdmin: Guard;
+    None: Guard;
+    Owner: Guard;
+};
+export declare const Pubsub: {
+    Public: Guard;
+    Every: Guard;
+    Admin: Guard;
+    User: Guard;
+    SuperAdmin: Guard;
+    None: Guard;
+    Owner: Guard;
+};
+export declare const Process: {
+    Federation: Guard;
+    Batch: Guard;
+    All: Guard;
+};
+export declare function ResolveField(returns: ReturnType, argsOption?: ArgsOption): (target: any, key: string, descriptor: PropertyDescriptor) => void;
+export declare const Arg: {
+    Body: (name: string, returns: ReturnType, argsOption?: ArgsOption) => (prototype: object, key: string, idx: number) => void;
+    Param: (name: string, returns: ReturnType, argsOption?: ArgsOption) => (prototype: object, key: string, idx: number) => void;
+    Query: (name: string, returns: ReturnType, argsOption?: ArgsOption) => (prototype: object, key: string, idx: number) => void;
+    Upload: (name: string, returns: ReturnType, argsOption?: ArgsOption) => (prototype: object, key: string, idx: number) => void;
+    Msg: (name: string, returns: ReturnType, argsOption?: ArgsOption) => (prototype: object, key: string, idx: number) => void;
+    Room: (name: string, returns: ReturnType, argsOption?: ArgsOption) => (prototype: object, key: string, idx: number) => void;
+};
+export declare function Parent(): (prototype: object, key: string, idx: number) => void;
+export declare function LogSignal<Srv>(srv: Srv): Type<{ [K in keyof Srv as K extends string ? Uncapitalize<K> : never]: Srv[K]; }>;
+type UnType<Class> = Class extends Type<infer T> ? T : never;
+export type DefaultSignal<T extends string, Input, Full, Light, Insight, Filter extends FilterType> = DefaultSignalWithQuerySort<T, Input, Full, Light, Insight, GetActionObject<Filter>, SortOf<Filter>>;
+type DefaultSignalWithQuerySort<T extends string, Input, Full, Light, Insight, Query, Sort> = {
+    [K in Uncapitalize<T>]: (id: string) => Promise<Full>;
+} & {
+    [K in `light${Capitalize<T>}`]: (id: string) => Promise<Light>;
+} & {
+    [K in `${Uncapitalize<T>}List`]: (...args: [query: Query, skip: number | null, limit: number | null, sort: Sort | null]) => Promise<Full[]>;
+} & {
+    [K in `${Uncapitalize<T>}Insight`]: (query: Query) => Promise<Insight>;
+} & {
+    [K in `${Uncapitalize<T>}Exists`]: (query: Query) => Promise<boolean>;
+} & {
+    [K in `create${Capitalize<T>}`]: (data: DocumentModel<Input>, account: Account) => Promise<Full>;
+} & {
+    [K in `update${Capitalize<T>}`]: (id: string, data: DocumentModel<Input>, account: Account) => Promise<Full>;
+} & {
+    [K in `remove${Capitalize<T>}`]: (id: string, account: Account) => Promise<Full>;
+};
+export declare function DbSignal<Srv>(constant: ConstantModel<string, any, BaseObject & {
+    status: string;
+}, BaseObject, {
+    count: number;
+}, any>, srv: Srv, option: {
+    guards: {
+        get: Guard;
+        cru: Guard;
+    };
+    omit?: ("get" | "list" | "insight" | "exist" | "create" | "update" | "remove")[];
+}): Type<{ [K in keyof Srv as K extends string ? Uncapitalize<K> : never]: Srv[K]; }>;
+export declare const getSigMeta: (sigRef: Type) => SignalMeta;
+export declare const getGqlMeta: (sigRef: Type, key: string) => GqlMeta;
+export declare const getGqlMetaMapOnPrototype: (prototype: object) => Map<string, GqlMeta>;
+export declare const getGqlMetas: (sigRef: Type) => GqlMeta[];
+export declare const setGqlMetaMapOnPrototype: (prototype: object, gqlMetaMap: Map<string, GqlMeta>) => void;
+export declare const getArgMetas: (sigRef: Type, key: string) => [ArgMeta[], InternalArgMeta[]];
+export declare const setArgMetas: (sigRef: Type, key: string, argMetas: ArgMeta[], internalArgMetas: InternalArgMeta[]) => void;
+export declare const getResolveFieldMetas: (sigRef: Type) => ResolveFieldMeta[];
+export declare const getControllerPrefix: (sigMeta: SignalMeta) => string | undefined;
+export declare const getControllerPath: (gqlMeta: GqlMeta, paramArgMetas: ArgMeta[]) => string;
+export declare const copySignal: (sigRef: Type) => {
+    new (): {};
+};
+export {};