@akanjs/constant 0.0.44 → 0.0.46

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (2) hide show
  1. package/index.js +600 -873
  2. package/package.json +1 -3
package/index.js CHANGED
@@ -1,892 +1,619 @@
1
- (() => {
2
- var __create = Object.create;
3
- var __defProp = Object.defineProperty;
4
- var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
5
- var __getOwnPropNames = Object.getOwnPropertyNames;
6
- var __getProtoOf = Object.getPrototypeOf;
7
- var __hasOwnProp = Object.prototype.hasOwnProperty;
8
- var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
9
- get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
10
- }) : x)(function(x) {
11
- if (typeof require !== "undefined")
12
- return require.apply(this, arguments);
13
- throw Error('Dynamic require of "' + x + '" is not supported');
14
- });
15
- var __copyProps = (to, from2, except, desc) => {
16
- if (from2 && typeof from2 === "object" || typeof from2 === "function") {
17
- for (let key of __getOwnPropNames(from2))
18
- if (!__hasOwnProp.call(to, key) && key !== except)
19
- __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
20
- }
21
- return to;
22
- };
23
- var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
24
- // If the importer is in node compatibility mode or this is not an ESM
25
- // file that has been converted to a CommonJS file using a Babel-
26
- // compatible transform (i.e. "__esModule" has not been set), then set
27
- // "default" to the CommonJS "module.exports" for node compatibility.
28
- isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
29
- mod
30
- ));
31
- var __decorateClass = (decorators, target, key, kind) => {
32
- var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
33
- for (var i = decorators.length - 1, decorator; i >= 0; i--)
34
- if (decorator = decorators[i])
35
- result = (kind ? decorator(target, key, result) : decorator(result)) || result;
36
- if (kind && result)
37
- __defProp(target, key, result);
38
- return result;
39
- };
40
- var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
1
+ var __defProp = Object.defineProperty;
2
+ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
3
+ var __getOwnPropNames = Object.getOwnPropertyNames;
4
+ var __hasOwnProp = Object.prototype.hasOwnProperty;
5
+ var __export = (target, all) => {
6
+ for (var name in all)
7
+ __defProp(target, name, { get: all[name], enumerable: true });
8
+ };
9
+ var __copyProps = (to, from2, except, desc) => {
10
+ if (from2 && typeof from2 === "object" || typeof from2 === "function") {
11
+ for (let key of __getOwnPropNames(from2))
12
+ if (!__hasOwnProp.call(to, key) && key !== except)
13
+ __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
14
+ }
15
+ return to;
16
+ };
17
+ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
18
+ var __decorateClass = (decorators, target, key, kind) => {
19
+ var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
20
+ for (var i = decorators.length - 1, decorator; i >= 0; i--)
21
+ if (decorator = decorators[i])
22
+ result = (kind ? decorator(target, key, result) : decorator(result)) || result;
23
+ if (kind && result)
24
+ __defProp(target, key, result);
25
+ return result;
26
+ };
27
+ var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
41
28
 
42
- // pkgs/@akanjs/constant/src/types.ts
43
- var defaultListOption = {
44
- limit: 20,
45
- skip: 0,
46
- sort: "latest"
47
- };
48
- var DEFAULT_PAGE_SIZE = 20;
29
+ // pkgs/@akanjs/constant/index.ts
30
+ var constant_exports = {};
31
+ __export(constant_exports, {
32
+ BaseFilter: () => BaseFilter,
33
+ DEFAULT_PAGE_SIZE: () => DEFAULT_PAGE_SIZE,
34
+ Field: () => Field,
35
+ Filter: () => Filter,
36
+ FilterModelStorage: () => FilterModelStorage,
37
+ FullModelStorage: () => FullModelStorage,
38
+ InputModelStorage: () => InputModelStorage,
39
+ LightModelStorage: () => LightModelStorage,
40
+ Model: () => Model,
41
+ ScalarModelStorage: () => ScalarModelStorage,
42
+ as: () => as,
43
+ cnstOf: () => cnstOf,
44
+ defaultListOption: () => defaultListOption,
45
+ fieldTypes: () => fieldTypes,
46
+ from: () => from,
47
+ getAllFilterModelRefs: () => getAllFilterModelRefs,
48
+ getAllFullModelRefs: () => getAllFullModelRefs,
49
+ getAllScalarModelRefs: () => getAllScalarModelRefs,
50
+ getChildClassRefs: () => getChildClassRefs,
51
+ getClassMeta: () => getClassMeta,
52
+ getCnstMeta: () => getCnstMeta,
53
+ getFieldEnumMetas: () => getFieldEnumMetas,
54
+ getFieldMetaMap: () => getFieldMetaMap,
55
+ getFieldMetaMapOnPrototype: () => getFieldMetaMapOnPrototype,
56
+ getFieldMetas: () => getFieldMetas,
57
+ getFilterArgMetas: () => getFilterArgMetas,
58
+ getFilterKeyMetaMapOnPrototype: () => getFilterKeyMetaMapOnPrototype,
59
+ getFilterMeta: () => getFilterMeta,
60
+ getFilterQuery: () => getFilterQuery,
61
+ getFilterQueryMap: () => getFilterQueryMap,
62
+ getFilterSort: () => getFilterSort,
63
+ getFilterSortMap: () => getFilterSortMap,
64
+ getFullModelRef: () => getFullModelRef,
65
+ getGqlTypeStr: () => getGqlTypeStr,
66
+ getInputModelRef: () => getInputModelRef,
67
+ getLightModelRef: () => getLightModelRef,
68
+ getQueryMap: () => getQueryMap,
69
+ getScalarExample: () => getScalarExample,
70
+ getScalarModelRef: () => getScalarModelRef,
71
+ hasTextField: () => hasTextField,
72
+ isConstantModel: () => isConstantModel,
73
+ isFilterModel: () => isFilterModel,
74
+ mixModelOf: () => mixModelOf,
75
+ over: () => over,
76
+ scalarExampleMap: () => scalarExampleMap,
77
+ setFieldMetaMap: () => setFieldMetaMap,
78
+ setFieldMetaMapOnPrototype: () => setFieldMetaMapOnPrototype,
79
+ setFilterArgMetasOnPrototype: () => setFilterArgMetasOnPrototype,
80
+ setFilterKeyMetaMapOnPrototype: () => setFilterKeyMetaMapOnPrototype,
81
+ setFilterMeta: () => setFilterMeta,
82
+ sortOf: () => sortOf,
83
+ via: () => via
84
+ });
85
+ module.exports = __toCommonJS(constant_exports);
49
86
 
50
- // pkgs/@akanjs/base/src/base.ts
51
- var version = "0.9.0";
52
- var logo = `
53
- _ _ _
54
- / \\ | | ____ _ _ __ (_)___
55
- / _ \\ | |/ / _' | '_ \\ | / __|
56
- / ___ \\| < (_| | | | |_ | \\__ \\
57
- /_/ \\_\\_|\\_\\__,_|_| |_(_)/ |___/
58
- |__/ ver ${version}
59
- ? See more details on docs https://www.akanjs.com/docs
60
- \u2605 Star Akanjs on GitHub https://github.com/aka-bassman/akanjs
87
+ // pkgs/@akanjs/constant/src/types.ts
88
+ var defaultListOption = {
89
+ limit: 20,
90
+ skip: 0,
91
+ sort: "latest"
92
+ };
93
+ var DEFAULT_PAGE_SIZE = 20;
61
94
 
62
- `;
95
+ // pkgs/@akanjs/constant/src/fieldMeta.ts
96
+ var import_base2 = require("@akanjs/base");
63
97
 
64
- // pkgs/@akanjs/base/src/baseEnv.ts
65
- var appName = process.env.NEXT_PUBLIC_APP_NAME ?? "unknown";
66
- var repoName = process.env.NEXT_PUBLIC_REPO_NAME ?? "unknown";
67
- var serveDomain = process.env.NEXT_PUBLIC_SERVE_DOMAIN ?? "unknown";
68
- if (appName === "unknown")
69
- throw new Error("environment variable NEXT_PUBLIC_APP_NAME is required");
70
- if (repoName === "unknown")
71
- throw new Error("environment variable NEXT_PUBLIC_REPO_NAME is required");
72
- if (serveDomain === "unknown")
73
- throw new Error("environment variable NEXT_PUBLIC_SERVE_DOMAIN is required");
74
- var environment = process.env.NEXT_PUBLIC_ENV ?? "debug";
75
- var operationType = typeof window !== "undefined" ? "client" : process.env.NEXT_RUNTIME ? "client" : "server";
76
- var operationMode = process.env.NEXT_PUBLIC_OPERATION_MODE ?? "cloud";
77
- var networkType = process.env.NEXT_PUBLIC_NETWORK_TYPE ?? (environment === "main" ? "mainnet" : environment === "develop" ? "testnet" : "debugnet");
78
- var tunnelUsername = process.env.SSU_TUNNEL_USERNAME ?? "root";
79
- var tunnelPassword = process.env.SSU_TUNNEL_PASSWORD ?? repoName;
80
- var baseEnv = {
81
- repoName,
82
- serveDomain,
83
- appName,
84
- environment,
85
- operationType,
86
- operationMode,
87
- networkType,
88
- tunnelUsername,
89
- tunnelPassword
90
- };
91
- var side = typeof window === "undefined" ? "server" : "client";
92
- var renderMode = process.env.RENDER_ENV ?? "ssr";
93
- var clientHost = process.env.NEXT_PUBLIC_CLIENT_HOST ?? (operationMode === "local" || side === "server" ? "localhost" : window.location.hostname);
94
- var clientPort = parseInt(
95
- process.env.NEXT_PUBLIC_CLIENT_PORT ?? (operationMode === "local" ? renderMode === "ssr" ? "4200" : "4201" : "443")
96
- );
97
- var clientHttpProtocol = side === "client" ? window.location.protocol : clientHost === "localhost" ? "http:" : "https:";
98
- var clientHttpUri = `${clientHttpProtocol}//${clientHost}${clientPort === 443 ? "" : `:${clientPort}`}`;
99
- var serverHost = process.env.SERVER_HOST ?? (operationMode === "local" ? typeof window === "undefined" ? "localhost" : window.location.host.split(":")[0] : renderMode === "csr" ? `${appName}-${environment}.${serveDomain}` : side === "client" ? window.location.host.split(":")[0] : operationMode === "cloud" ? `backend-svc.${appName}-${environment}.svc.cluster.local` : "localhost");
100
- var serverPort = parseInt(
101
- process.env.SERVER_PORT ?? (operationMode === "local" || side === "server" ? "8080" : "443")
98
+ // pkgs/@akanjs/constant/src/scalar.ts
99
+ var import_reflect_metadata = require("reflect-metadata");
100
+ var import_base = require("@akanjs/base");
101
+ var scalarExampleMap = /* @__PURE__ */ new Map([
102
+ [import_base.ID, "1234567890abcdef12345678"],
103
+ [import_base.Int, 0],
104
+ [import_base.Float, 0],
105
+ [String, "String"],
106
+ [Boolean, true],
107
+ [Date, (/* @__PURE__ */ new Date()).toISOString()],
108
+ [import_base.Upload, "FileUpload"],
109
+ [import_base.JSON, {}],
110
+ [Map, {}]
111
+ ]);
112
+ var getScalarExample = (ref) => scalarExampleMap.get(ref) ?? null;
113
+ var getGqlTypeStr = (ref) => import_base.scalarNameMap.get(ref) ?? getClassMeta(ref).refName;
114
+ var fieldTypes = ["email", "password", "url"];
115
+ var getClassMeta = (modelRef) => {
116
+ const [target] = (0, import_base.getNonArrayModel)(modelRef);
117
+ const classMeta = Reflect.getMetadata("class", target.prototype);
118
+ if (!classMeta)
119
+ throw new Error(`No ClassMeta for this target ${target.name}`);
120
+ return classMeta;
121
+ };
122
+ var getFieldMetas = (modelRef) => {
123
+ const [target] = (0, import_base.getNonArrayModel)(modelRef);
124
+ const metadataMap = Reflect.getMetadata("fields", target.prototype) ?? /* @__PURE__ */ new Map();
125
+ const keySortMap = { id: -1, createdAt: 1, updatedAt: 2, removedAt: 3 };
126
+ return [...metadataMap.values()].sort((a, b) => (keySortMap[a.key] ?? 0) - (keySortMap[b.key] ?? 0));
127
+ };
128
+ var isConstantModel = (modelRef) => {
129
+ return Reflect.getMetadata("class", modelRef.prototype) !== void 0;
130
+ };
131
+ var getFieldMetaMap = (modelRef) => {
132
+ const [target] = (0, import_base.getNonArrayModel)(modelRef);
133
+ const metadataMap = Reflect.getMetadata("fields", target.prototype) ?? /* @__PURE__ */ new Map();
134
+ return new Map(metadataMap);
135
+ };
136
+ var setFieldMetaMap = (modelRef, metadataMap) => {
137
+ const [target] = (0, import_base.getNonArrayModel)(modelRef);
138
+ Reflect.defineMetadata("fields", new Map(metadataMap), target.prototype);
139
+ };
140
+ var getFieldMetaMapOnPrototype = (prototype) => {
141
+ const metadataMap = Reflect.getMetadata("fields", prototype) ?? /* @__PURE__ */ new Map();
142
+ return new Map(metadataMap);
143
+ };
144
+ var setFieldMetaMapOnPrototype = (prototype, metadataMap) => {
145
+ Reflect.defineMetadata("fields", new Map(metadataMap), prototype);
146
+ };
147
+ var getQueryMap = (modelRef) => {
148
+ const fieldMetas = getFieldMetas(modelRef);
149
+ return Object.fromEntries(
150
+ fieldMetas.filter((fieldMeta) => !!fieldMeta.query).map((fieldMeta) => [fieldMeta.key, fieldMeta.query])
102
151
  );
103
- var serverHttpProtocol = side === "client" ? window.location.protocol : "http:";
104
- var serverHttpUri = `${serverHttpProtocol}//${serverHost}${serverPort === 443 ? "" : `:${serverPort}`}/backend`;
105
- var serverGraphqlUri = `${serverHttpUri}/graphql`;
106
- var serverWsProtocol = serverHttpProtocol === "http:" ? "ws:" : "wss:";
107
- var serverWsUri = `${serverWsProtocol}//${serverHost}${serverPort === 443 ? "" : `:${serverPort}`}`;
108
- var baseClientEnv = {
109
- ...baseEnv,
110
- side,
111
- renderMode,
112
- websocket: true,
113
- clientHost,
114
- clientPort,
115
- clientHttpProtocol,
116
- clientHttpUri,
117
- serverHost,
118
- serverPort,
119
- serverHttpProtocol,
120
- serverHttpUri,
121
- serverGraphqlUri,
122
- serverWsProtocol,
123
- serverWsUri
124
- };
152
+ };
125
153
 
126
- // pkgs/@akanjs/base/src/scalar.ts
127
- var import_dayjs = __toESM(__require("dayjs"));
128
- var dayjs = import_dayjs.default;
129
- var Int = class {
130
- __Scalar__;
131
- };
132
- var Upload = class {
133
- __Scalar__;
134
- filename;
135
- mimetype;
136
- encoding;
137
- createReadStream;
138
- };
139
- var Float = class {
140
- __Scalar__;
141
- };
142
- var ID = class {
143
- __Scalar__;
144
- };
145
- var JSON = class {
146
- __Scalar__;
147
- };
148
- var getNonArrayModel = (arraiedModel) => {
149
- let arrDepth = 0;
150
- let target = arraiedModel;
151
- while (Array.isArray(target)) {
152
- target = target[0];
153
- arrDepth++;
154
- }
155
- return [target, arrDepth];
156
- };
157
- var scalarSet = /* @__PURE__ */ new Set([String, Boolean, Date, ID, Int, Float, Upload, JSON, Map]);
158
- var scalarNameMap = /* @__PURE__ */ new Map([
159
- [ID, "ID"],
160
- [Int, "Int"],
161
- [Float, "Float"],
162
- [String, "String"],
163
- [Boolean, "Boolean"],
164
- [Date, "Date"],
165
- [Upload, "Upload"],
166
- [JSON, "JSON"],
167
- [Map, "Map"]
168
- ]);
169
- var scalarArgMap = /* @__PURE__ */ new Map([
170
- [ID, null],
171
- [String, ""],
172
- [Boolean, false],
173
- [Date, dayjs(/* @__PURE__ */ new Date(-1))],
174
- [Int, 0],
175
- [Float, 0],
176
- [JSON, {}],
177
- [Map, {}]
178
- ]);
179
- var scalarDefaultMap = /* @__PURE__ */ new Map([
180
- [ID, null],
181
- [String, ""],
182
- [Boolean, false],
183
- [Date, dayjs(/* @__PURE__ */ new Date(-1))],
184
- [Int, 0],
185
- [Float, 0],
186
- [JSON, {}]
187
- ]);
188
- var isGqlScalar = (modelRef) => scalarSet.has(modelRef);
189
- var isGqlMap = (modelRef) => modelRef === Map;
190
-
191
- // pkgs/@akanjs/constant/src/scalar.ts
192
- var import_reflect_metadata = __require("reflect-metadata");
193
- var scalarExampleMap = /* @__PURE__ */ new Map([
194
- [ID, "1234567890abcdef12345678"],
195
- [Int, 0],
196
- [Float, 0],
197
- [String, "String"],
198
- [Boolean, true],
199
- [Date, (/* @__PURE__ */ new Date()).toISOString()],
200
- [Upload, "FileUpload"],
201
- [JSON, {}],
202
- [Map, {}]
203
- ]);
204
- var getScalarExample = (ref) => scalarExampleMap.get(ref) ?? null;
205
- var getGqlTypeStr = (ref) => scalarNameMap.get(ref) ?? getClassMeta(ref).refName;
206
- var fieldTypes = ["email", "password", "url"];
207
- var getClassMeta = (modelRef) => {
208
- const [target] = getNonArrayModel(modelRef);
209
- const classMeta = Reflect.getMetadata("class", target.prototype);
210
- if (!classMeta)
211
- throw new Error(`No ClassMeta for this target ${target.name}`);
212
- return classMeta;
213
- };
214
- var getFieldMetas = (modelRef) => {
215
- const [target] = getNonArrayModel(modelRef);
216
- const metadataMap = Reflect.getMetadata("fields", target.prototype) ?? /* @__PURE__ */ new Map();
217
- const keySortMap = { id: -1, createdAt: 1, updatedAt: 2, removedAt: 3 };
218
- return [...metadataMap.values()].sort((a, b) => (keySortMap[a.key] ?? 0) - (keySortMap[b.key] ?? 0));
219
- };
220
- var isConstantModel = (modelRef) => {
221
- return Reflect.getMetadata("class", modelRef.prototype) !== void 0;
222
- };
223
- var getFieldMetaMap = (modelRef) => {
224
- const [target] = getNonArrayModel(modelRef);
225
- const metadataMap = Reflect.getMetadata("fields", target.prototype) ?? /* @__PURE__ */ new Map();
226
- return new Map(metadataMap);
227
- };
228
- var setFieldMetaMap = (modelRef, metadataMap) => {
229
- const [target] = getNonArrayModel(modelRef);
230
- Reflect.defineMetadata("fields", new Map(metadataMap), target.prototype);
231
- };
232
- var getFieldMetaMapOnPrototype = (prototype) => {
233
- const metadataMap = Reflect.getMetadata("fields", prototype) ?? /* @__PURE__ */ new Map();
234
- return new Map(metadataMap);
235
- };
236
- var setFieldMetaMapOnPrototype = (prototype, metadataMap) => {
237
- Reflect.defineMetadata("fields", new Map(metadataMap), prototype);
238
- };
239
- var getQueryMap = (modelRef) => {
240
- const fieldMetas = getFieldMetas(modelRef);
241
- return Object.fromEntries(
242
- fieldMetas.filter((fieldMeta) => !!fieldMeta.query).map((fieldMeta) => [fieldMeta.key, fieldMeta.query])
243
- );
244
- };
245
-
246
- // pkgs/@akanjs/constant/src/fieldMeta.ts
247
- var applyFieldMeta = (modelRef, arrDepth, option, optionArrDepth) => {
248
- const isArray = arrDepth > 0;
249
- const isClass = !isGqlScalar(modelRef);
250
- const isMap = isGqlMap(modelRef);
251
- const { refName, type } = isClass ? getClassMeta(modelRef) : { refName: "", type: "scalar" };
252
- const name = isClass ? refName : scalarNameMap.get(modelRef) ?? "Unknown";
253
- if (isMap && !option.of)
254
- throw new Error("Map type must have 'of' option");
255
- return (prototype, key) => {
256
- const metadata = {
257
- nullable: option.nullable ?? false,
258
- ref: option.ref,
259
- refPath: option.refPath,
260
- refType: option.refType,
261
- default: option.default ?? (isArray ? [] : null),
262
- type: option.type,
263
- fieldType: option.fieldType ?? "property",
264
- immutable: option.immutable ?? false,
265
- min: option.min,
266
- max: option.max,
267
- enum: option.enum,
268
- select: option.select ?? true,
269
- minlength: option.minlength,
270
- maxlength: option.maxlength,
271
- query: option.query,
272
- accumulate: option.accumulate,
273
- example: option.example,
274
- validate: option.validate,
275
- key,
276
- name,
277
- isClass,
278
- isScalar: type === "scalar",
279
- modelRef,
280
- arrDepth,
281
- isArray,
282
- optArrDepth: optionArrDepth,
283
- isMap,
284
- of: option.of,
285
- text: option.text
286
- };
287
- const metadataMap = getFieldMetaMapOnPrototype(prototype);
288
- metadataMap.set(key, metadata);
289
- setFieldMetaMapOnPrototype(prototype, metadataMap);
154
+ // pkgs/@akanjs/constant/src/fieldMeta.ts
155
+ var applyFieldMeta = (modelRef, arrDepth, option, optionArrDepth) => {
156
+ const isArray = arrDepth > 0;
157
+ const isClass = !(0, import_base2.isGqlScalar)(modelRef);
158
+ const isMap = (0, import_base2.isGqlMap)(modelRef);
159
+ const { refName, type } = isClass ? getClassMeta(modelRef) : { refName: "", type: "scalar" };
160
+ const name = isClass ? refName : import_base2.scalarNameMap.get(modelRef) ?? "Unknown";
161
+ if (isMap && !option.of)
162
+ throw new Error("Map type must have 'of' option");
163
+ return (prototype, key) => {
164
+ const metadata = {
165
+ nullable: option.nullable ?? false,
166
+ ref: option.ref,
167
+ refPath: option.refPath,
168
+ refType: option.refType,
169
+ default: option.default ?? (isArray ? [] : null),
170
+ type: option.type,
171
+ fieldType: option.fieldType ?? "property",
172
+ immutable: option.immutable ?? false,
173
+ min: option.min,
174
+ max: option.max,
175
+ enum: option.enum,
176
+ select: option.select ?? true,
177
+ minlength: option.minlength,
178
+ maxlength: option.maxlength,
179
+ query: option.query,
180
+ accumulate: option.accumulate,
181
+ example: option.example,
182
+ validate: option.validate,
183
+ key,
184
+ name,
185
+ isClass,
186
+ isScalar: type === "scalar",
187
+ modelRef,
188
+ arrDepth,
189
+ isArray,
190
+ optArrDepth: optionArrDepth,
191
+ isMap,
192
+ of: option.of,
193
+ text: option.text
290
194
  };
291
- };
292
- var makeField = (customOption) => (returns, fieldOption) => {
293
- const [modelRef, arrDepth] = getNonArrayModel(returns());
294
- if (!fieldOption)
295
- return applyFieldMeta(modelRef, arrDepth, { ...customOption }, arrDepth);
296
- const [opt, optArrDepth] = getNonArrayModel(fieldOption);
297
- return applyFieldMeta(modelRef, arrDepth, { ...opt, ...customOption }, optArrDepth);
298
- };
299
- var Field = {
300
- Prop: makeField({ fieldType: "property" }),
301
- Hidden: makeField({ fieldType: "hidden", nullable: true }),
302
- Secret: makeField({ fieldType: "hidden", select: false, nullable: true }),
303
- Resolve: makeField({ fieldType: "resolve" })
304
- };
195
+ const metadataMap = getFieldMetaMapOnPrototype(prototype);
196
+ metadataMap.set(key, metadata);
197
+ setFieldMetaMapOnPrototype(prototype, metadataMap);
198
+ };
199
+ };
200
+ var makeField = (customOption) => (returns, fieldOption) => {
201
+ const [modelRef, arrDepth] = (0, import_base2.getNonArrayModel)(returns());
202
+ if (!fieldOption)
203
+ return applyFieldMeta(modelRef, arrDepth, { ...customOption }, arrDepth);
204
+ const [opt, optArrDepth] = (0, import_base2.getNonArrayModel)(fieldOption);
205
+ return applyFieldMeta(modelRef, arrDepth, { ...opt, ...customOption }, optArrDepth);
206
+ };
207
+ var Field = {
208
+ Prop: makeField({ fieldType: "property" }),
209
+ Hidden: makeField({ fieldType: "hidden", nullable: true }),
210
+ Secret: makeField({ fieldType: "hidden", select: false, nullable: true }),
211
+ Resolve: makeField({ fieldType: "resolve" })
212
+ };
305
213
 
306
- // pkgs/@akanjs/constant/src/constantDecorator.ts
307
- var import_reflect_metadata2 = __require("reflect-metadata");
308
- var CnstStorage = class {
309
- };
310
- var setCnstMeta = (refName, cnst) => {
311
- Reflect.defineMetadata(refName, cnst, CnstStorage.prototype);
312
- };
313
- var getCnstMeta = (refName) => {
314
- const cnst = Reflect.getMetadata(refName, CnstStorage.prototype);
315
- if (!cnst)
316
- throw new Error(`No cnst meta for ${refName}`);
317
- return cnst;
318
- };
319
- var cnstOf = (refName, Input, Full, Light, Insight, Filter2, Summary) => {
320
- const cnst = { refName, Input, Full, Light, Insight, Filter: Filter2, Summary };
321
- setCnstMeta(refName, cnst);
322
- return cnst;
323
- };
214
+ // pkgs/@akanjs/constant/src/constantDecorator.ts
215
+ var import_reflect_metadata2 = require("reflect-metadata");
216
+ var CnstStorage = class {
217
+ };
218
+ var setCnstMeta = (refName, cnst) => {
219
+ Reflect.defineMetadata(refName, cnst, CnstStorage.prototype);
220
+ };
221
+ var getCnstMeta = (refName) => {
222
+ const cnst = Reflect.getMetadata(refName, CnstStorage.prototype);
223
+ if (!cnst)
224
+ throw new Error(`No cnst meta for ${refName}`);
225
+ return cnst;
226
+ };
227
+ var cnstOf = (refName, Input, Full, Light, Insight, Filter2, Summary) => {
228
+ const cnst = { refName, Input, Full, Light, Insight, Filter: Filter2, Summary };
229
+ setCnstMeta(refName, cnst);
230
+ return cnst;
231
+ };
324
232
 
325
- // pkgs/@akanjs/constant/src/filterMeta.ts
326
- var isFilterModel = (filterRef) => {
327
- return Reflect.getMetadata("filter", filterRef.prototype) !== void 0;
328
- };
329
- var getFilterMeta = (filterRef) => {
330
- const filterMeta = Reflect.getMetadata("filter", filterRef.prototype);
331
- if (!filterMeta)
332
- throw new Error("filterMeta is not defined");
333
- return filterMeta;
334
- };
335
- var setFilterMeta = (filterRef, filterMeta) => {
336
- const existingFilterMeta = Reflect.getMetadata("filter", filterRef.prototype);
337
- if (existingFilterMeta)
338
- Object.assign(filterMeta.sort, existingFilterMeta.sort);
339
- Reflect.defineMetadata("filter", filterMeta, filterRef.prototype);
340
- };
341
- var getFilterKeyMetaMapOnPrototype = (prototype) => {
342
- const metadataMap = Reflect.getMetadata("filterKey", prototype) ?? /* @__PURE__ */ new Map();
343
- return new Map(metadataMap);
344
- };
345
- var setFilterKeyMetaMapOnPrototype = (prototype, metadataMap) => {
346
- Reflect.defineMetadata("filterKey", new Map(metadataMap), prototype);
347
- };
348
- var applyFilterKeyMeta = (option) => {
349
- return (prototype, key, descriptor) => {
350
- const metadata = { key, ...option, descriptor };
351
- const metadataMap = getFilterKeyMetaMapOnPrototype(prototype);
352
- metadataMap.set(key, metadata);
353
- setFilterKeyMetaMapOnPrototype(prototype, metadataMap);
354
- };
355
- };
356
- var makeFilter = (customOption) => (fieldOption) => {
357
- return applyFilterKeyMeta({ ...customOption, ...fieldOption });
358
- };
359
- var getFilterArgMetasOnPrototype = (prototype, key) => {
360
- const filterArgMetas = Reflect.getMetadata("filterArg", prototype, key) ?? [];
361
- return filterArgMetas;
362
- };
363
- var setFilterArgMetasOnPrototype = (prototype, key, filterArgMetas) => {
364
- Reflect.defineMetadata("filterArg", filterArgMetas, prototype, key);
365
- };
366
- var getFilterArgMetas = (filterRef, key) => {
367
- const filterArgMetas = getFilterArgMetasOnPrototype(filterRef.prototype, key);
368
- return filterArgMetas;
369
- };
370
- var applyFilterArgMeta = (name, returns, argOption) => {
371
- return (prototype, key, idx) => {
372
- const [modelRef, arrDepth] = getNonArrayModel(returns());
373
- const [opt, optArrDepth] = getNonArrayModel(argOption ?? {});
374
- const filterArgMeta = { name, ...opt, modelRef, arrDepth, isArray: arrDepth > 0, optArrDepth };
375
- const filterArgMetas = getFilterArgMetasOnPrototype(prototype, key);
376
- filterArgMetas[idx] = filterArgMeta;
377
- setFilterArgMetasOnPrototype(prototype, key, filterArgMetas);
378
- };
379
- };
380
- var getFilterQuery = (filterRef, key) => {
381
- const filterKeyMetaMap = getFilterKeyMetaMapOnPrototype(filterRef.prototype);
382
- const filterKeyMeta = filterKeyMetaMap.get(key);
383
- if (!filterKeyMeta?.descriptor.value)
384
- throw new Error(`filterKeyMeta is not defined for key: ${key}`);
385
- return filterKeyMeta.descriptor.value;
386
- };
387
- var getFilterQueryMap = (filterRef) => {
388
- const filterKeyMetaMap = getFilterKeyMetaMapOnPrototype(filterRef.prototype);
389
- return filterKeyMetaMap;
390
- };
391
- var getFilterSort = (filterRef, key) => {
392
- const filterMeta = getFilterMeta(filterRef);
393
- const sort = filterMeta.sort[key];
394
- return sort;
395
- };
396
- var getFilterSortMap = (filterRef) => {
397
- const filterMeta = getFilterMeta(filterRef);
398
- return filterMeta.sort;
399
- };
400
- var Filter = {
401
- Mongo: makeFilter({ type: "mongo" }),
402
- // Meili: makeFilter({ fieldType: "hidden", nullable: true }),
403
- Arg: applyFilterArgMeta
404
- };
405
- var sortOf = (modelRef, sort) => {
406
- const fieldMetaMap = getFieldMetaMap(modelRef);
407
- const statusFieldMeta = fieldMetaMap.get("status");
408
- if (!statusFieldMeta)
409
- throw new Error(`No status field meta fount in ${modelRef.name}`);
410
- class BaseFilter2 {
411
- latest = { createdAt: -1 };
412
- oldest = { createdAt: 1 };
413
- any() {
414
- return { removedAt: { $exists: false } };
415
- }
416
- byStatuses(statuses) {
417
- return statuses?.length ? { status: { $in: statuses } } : {};
418
- }
233
+ // pkgs/@akanjs/constant/src/filterMeta.ts
234
+ var import_base3 = require("@akanjs/base");
235
+ var isFilterModel = (filterRef) => {
236
+ return Reflect.getMetadata("filter", filterRef.prototype) !== void 0;
237
+ };
238
+ var getFilterMeta = (filterRef) => {
239
+ const filterMeta = Reflect.getMetadata("filter", filterRef.prototype);
240
+ if (!filterMeta)
241
+ throw new Error("filterMeta is not defined");
242
+ return filterMeta;
243
+ };
244
+ var setFilterMeta = (filterRef, filterMeta) => {
245
+ const existingFilterMeta = Reflect.getMetadata("filter", filterRef.prototype);
246
+ if (existingFilterMeta)
247
+ Object.assign(filterMeta.sort, existingFilterMeta.sort);
248
+ Reflect.defineMetadata("filter", filterMeta, filterRef.prototype);
249
+ };
250
+ var getFilterKeyMetaMapOnPrototype = (prototype) => {
251
+ const metadataMap = Reflect.getMetadata("filterKey", prototype) ?? /* @__PURE__ */ new Map();
252
+ return new Map(metadataMap);
253
+ };
254
+ var setFilterKeyMetaMapOnPrototype = (prototype, metadataMap) => {
255
+ Reflect.defineMetadata("filterKey", new Map(metadataMap), prototype);
256
+ };
257
+ var applyFilterKeyMeta = (option) => {
258
+ return (prototype, key, descriptor) => {
259
+ const metadata = { key, ...option, descriptor };
260
+ const metadataMap = getFilterKeyMetaMapOnPrototype(prototype);
261
+ metadataMap.set(key, metadata);
262
+ setFilterKeyMetaMapOnPrototype(prototype, metadataMap);
263
+ };
264
+ };
265
+ var makeFilter = (customOption) => (fieldOption) => {
266
+ return applyFilterKeyMeta({ ...customOption, ...fieldOption });
267
+ };
268
+ var getFilterArgMetasOnPrototype = (prototype, key) => {
269
+ const filterArgMetas = Reflect.getMetadata("filterArg", prototype, key) ?? [];
270
+ return filterArgMetas;
271
+ };
272
+ var setFilterArgMetasOnPrototype = (prototype, key, filterArgMetas) => {
273
+ Reflect.defineMetadata("filterArg", filterArgMetas, prototype, key);
274
+ };
275
+ var getFilterArgMetas = (filterRef, key) => {
276
+ const filterArgMetas = getFilterArgMetasOnPrototype(filterRef.prototype, key);
277
+ return filterArgMetas;
278
+ };
279
+ var applyFilterArgMeta = (name, returns, argOption) => {
280
+ return (prototype, key, idx) => {
281
+ const [modelRef, arrDepth] = (0, import_base3.getNonArrayModel)(returns());
282
+ const [opt, optArrDepth] = (0, import_base3.getNonArrayModel)(argOption ?? {});
283
+ const filterArgMeta = { name, ...opt, modelRef, arrDepth, isArray: arrDepth > 0, optArrDepth };
284
+ const filterArgMetas = getFilterArgMetasOnPrototype(prototype, key);
285
+ filterArgMetas[idx] = filterArgMeta;
286
+ setFilterArgMetasOnPrototype(prototype, key, filterArgMetas);
287
+ };
288
+ };
289
+ var getFilterQuery = (filterRef, key) => {
290
+ const filterKeyMetaMap = getFilterKeyMetaMapOnPrototype(filterRef.prototype);
291
+ const filterKeyMeta = filterKeyMetaMap.get(key);
292
+ if (!filterKeyMeta?.descriptor.value)
293
+ throw new Error(`filterKeyMeta is not defined for key: ${key}`);
294
+ return filterKeyMeta.descriptor.value;
295
+ };
296
+ var getFilterQueryMap = (filterRef) => {
297
+ const filterKeyMetaMap = getFilterKeyMetaMapOnPrototype(filterRef.prototype);
298
+ return filterKeyMetaMap;
299
+ };
300
+ var getFilterSort = (filterRef, key) => {
301
+ const filterMeta = getFilterMeta(filterRef);
302
+ const sort = filterMeta.sort[key];
303
+ return sort;
304
+ };
305
+ var getFilterSortMap = (filterRef) => {
306
+ const filterMeta = getFilterMeta(filterRef);
307
+ return filterMeta.sort;
308
+ };
309
+ var Filter = {
310
+ Mongo: makeFilter({ type: "mongo" }),
311
+ // Meili: makeFilter({ fieldType: "hidden", nullable: true }),
312
+ Arg: applyFilterArgMeta
313
+ };
314
+ var sortOf = (modelRef, sort) => {
315
+ const fieldMetaMap = getFieldMetaMap(modelRef);
316
+ const statusFieldMeta = fieldMetaMap.get("status");
317
+ if (!statusFieldMeta)
318
+ throw new Error(`No status field meta fount in ${modelRef.name}`);
319
+ class BaseFilter2 {
320
+ latest = { createdAt: -1 };
321
+ oldest = { createdAt: 1 };
322
+ any() {
323
+ return { removedAt: { $exists: false } };
324
+ }
325
+ byStatuses(statuses) {
326
+ return statuses?.length ? { status: { $in: statuses } } : {};
419
327
  }
420
- __decorateClass([
421
- Filter.Mongo()
422
- ], BaseFilter2.prototype, "any", 1);
423
- __decorateClass([
424
- Filter.Mongo(),
425
- __decorateParam(0, Filter.Arg("statuses", () => [String], { nullable: true, enum: statusFieldMeta?.enum }))
426
- ], BaseFilter2.prototype, "byStatuses", 1);
427
- Object.assign(BaseFilter2.prototype, sort);
428
- setFilterMeta(BaseFilter2, {
429
- refName: "BaseFilter",
430
- sort: Object.assign({ latest: { createdAt: -1 }, oldest: { createdAt: 1 } }, sort)
431
- });
432
- return BaseFilter2;
433
- };
434
- function BaseFilter(modelRef, sort) {
435
- const fieldMetaMap = getFieldMetaMap(modelRef);
436
- const statusFieldMeta = fieldMetaMap.get("status");
437
- if (!statusFieldMeta)
438
- throw new Error(`No status field meta fount in ${modelRef.name}`);
439
- class BaseFilter2 {
440
- latest = { createdAt: -1 };
441
- oldest = { createdAt: 1 };
442
- any() {
443
- return { removedAt: { $exists: false } };
444
- }
445
- byStatuses(statuses) {
446
- return statuses?.length ? { status: { $in: statuses } } : {};
447
- }
328
+ }
329
+ __decorateClass([
330
+ Filter.Mongo()
331
+ ], BaseFilter2.prototype, "any", 1);
332
+ __decorateClass([
333
+ Filter.Mongo(),
334
+ __decorateParam(0, Filter.Arg("statuses", () => [String], { nullable: true, enum: statusFieldMeta?.enum }))
335
+ ], BaseFilter2.prototype, "byStatuses", 1);
336
+ Object.assign(BaseFilter2.prototype, sort);
337
+ setFilterMeta(BaseFilter2, {
338
+ refName: "BaseFilter",
339
+ sort: Object.assign({ latest: { createdAt: -1 }, oldest: { createdAt: 1 } }, sort)
340
+ });
341
+ return BaseFilter2;
342
+ };
343
+ function BaseFilter(modelRef, sort) {
344
+ const fieldMetaMap = getFieldMetaMap(modelRef);
345
+ const statusFieldMeta = fieldMetaMap.get("status");
346
+ if (!statusFieldMeta)
347
+ throw new Error(`No status field meta fount in ${modelRef.name}`);
348
+ class BaseFilter2 {
349
+ latest = { createdAt: -1 };
350
+ oldest = { createdAt: 1 };
351
+ any() {
352
+ return { removedAt: { $exists: false } };
353
+ }
354
+ byStatuses(statuses) {
355
+ return statuses?.length ? { status: { $in: statuses } } : {};
448
356
  }
449
- __decorateClass([
450
- Filter.Mongo()
451
- ], BaseFilter2.prototype, "any", 1);
452
- __decorateClass([
453
- Filter.Mongo(),
454
- __decorateParam(0, Filter.Arg("statuses", () => [String], { nullable: true, enum: statusFieldMeta?.enum }))
455
- ], BaseFilter2.prototype, "byStatuses", 1);
456
- Object.assign(BaseFilter2.prototype, sort);
457
- setFilterMeta(BaseFilter2, {
458
- refName: "BaseFilter",
459
- sort: Object.assign({ latest: { createdAt: -1 }, oldest: { createdAt: 1 } }, sort)
460
- });
461
- return BaseFilter2;
462
357
  }
358
+ __decorateClass([
359
+ Filter.Mongo()
360
+ ], BaseFilter2.prototype, "any", 1);
361
+ __decorateClass([
362
+ Filter.Mongo(),
363
+ __decorateParam(0, Filter.Arg("statuses", () => [String], { nullable: true, enum: statusFieldMeta?.enum }))
364
+ ], BaseFilter2.prototype, "byStatuses", 1);
365
+ Object.assign(BaseFilter2.prototype, sort);
366
+ setFilterMeta(BaseFilter2, {
367
+ refName: "BaseFilter",
368
+ sort: Object.assign({ latest: { createdAt: -1 }, oldest: { createdAt: 1 } }, sort)
369
+ });
370
+ return BaseFilter2;
371
+ }
463
372
 
464
- // pkgs/@akanjs/constant/src/baseGql.ts
465
- var import_reflect_metadata3 = __require("reflect-metadata");
466
-
467
- // pkgs/@akanjs/common/src/isDayjs.ts
468
- var import_dayjs2 = __require("dayjs");
469
-
470
- // pkgs/@akanjs/common/src/isQueryEqual.ts
471
- var import_dayjs3 = __toESM(__require("dayjs"));
472
-
473
- // pkgs/@akanjs/common/src/isValidDate.ts
474
- var import_dayjs4 = __toESM(__require("dayjs"));
475
- var import_customParseFormat = __toESM(__require("dayjs/plugin/customParseFormat"));
476
- import_dayjs4.default.extend(import_customParseFormat.default);
477
-
478
- // pkgs/@akanjs/common/src/pluralize.ts
479
- var import_pluralize = __toESM(__require("pluralize"));
480
-
481
- // pkgs/@akanjs/common/src/applyMixins.ts
482
- var getAllPropertyDescriptors = (objRef) => {
483
- const descriptors = {};
484
- let current = objRef.prototype;
485
- while (current) {
486
- Object.getOwnPropertyNames(current).forEach((name) => {
487
- descriptors[name] ??= Object.getOwnPropertyDescriptor(current, name);
488
- });
489
- current = Object.getPrototypeOf(current);
490
- }
491
- return descriptors;
492
- };
493
- var applyMixins = (derivedCtor, constructors, avoidKeys) => {
494
- constructors.forEach((baseCtor) => {
495
- Object.entries(getAllPropertyDescriptors(baseCtor)).forEach(([name, descriptor]) => {
496
- if (name === "constructor" || avoidKeys?.has(name))
497
- return;
498
- Object.defineProperty(derivedCtor.prototype, name, { ...descriptor, configurable: true });
373
+ // pkgs/@akanjs/constant/src/baseGql.ts
374
+ var import_reflect_metadata3 = require("reflect-metadata");
375
+ var import_base4 = require("@akanjs/base");
376
+ var import_common = require("@akanjs/common");
377
+ var defaultFieldMeta = {
378
+ fieldType: "property",
379
+ immutable: false,
380
+ select: true,
381
+ isClass: false,
382
+ isScalar: true,
383
+ nullable: false,
384
+ isArray: false,
385
+ arrDepth: 0,
386
+ optArrDepth: 0,
387
+ default: null,
388
+ isMap: false
389
+ };
390
+ var idFieldMeta = { ...defaultFieldMeta, key: "id", name: "ID", modelRef: import_base4.ID };
391
+ var createdAtFieldMeta = { ...defaultFieldMeta, key: "createdAt", name: "Date", modelRef: Date };
392
+ var updatedAtFieldMeta = { ...defaultFieldMeta, key: "updatedAt", name: "Date", modelRef: Date };
393
+ var removedAtFieldMeta = {
394
+ ...defaultFieldMeta,
395
+ key: "removedAt",
396
+ name: "Date",
397
+ modelRef: Date,
398
+ nullable: true,
399
+ default: null
400
+ };
401
+ var extendModel = (modelRef) => {
402
+ class BaseModel {
403
+ }
404
+ const metadataMap = getFieldMetaMap(modelRef);
405
+ setFieldMetaMap(BaseModel, metadataMap);
406
+ return BaseModel;
407
+ };
408
+ var as = extendModel;
409
+ var baseModelOf = (modelRef) => {
410
+ class BaseModel {
411
+ __ModelType__ = "full";
412
+ }
413
+ const metadataMap = getFieldMetaMap(modelRef);
414
+ metadataMap.set("id", idFieldMeta);
415
+ metadataMap.set("createdAt", createdAtFieldMeta);
416
+ metadataMap.set("updatedAt", updatedAtFieldMeta);
417
+ metadataMap.set("removedAt", removedAtFieldMeta);
418
+ Reflect.defineMetadata("fields", metadataMap, BaseModel.prototype);
419
+ return BaseModel;
420
+ };
421
+ var lightModelOf = (objectRef, fields) => {
422
+ const map = /* @__PURE__ */ new Map();
423
+ const metadataMap = getFieldMetaMap(objectRef);
424
+ class BaseGql {
425
+ __ModelType__ = "light";
426
+ }
427
+ ["id", ...fields, "createdAt", "updatedAt", "removedAt"].forEach((key) => map.set(key, metadataMap.get(key)));
428
+ Reflect.defineMetadata("fields", map, BaseGql.prototype);
429
+ return BaseGql;
430
+ };
431
+ var fullModelOf = (modelRef, lightRef, overwriteRef, overwriteLightRef) => {
432
+ const modelFieldMetaMap = getFieldMetaMap(modelRef);
433
+ const lightFieldMetaMap = getFieldMetaMap(lightRef);
434
+ (0, import_common.applyMixins)(modelRef, [lightRef]);
435
+ if (overwriteRef) {
436
+ (0, import_common.applyMixins)(overwriteRef, [modelRef]);
437
+ setFieldMetaMap(overwriteRef, modelFieldMetaMap);
438
+ }
439
+ if (overwriteLightRef) {
440
+ (0, import_common.applyMixins)(overwriteLightRef, [lightRef]);
441
+ setFieldMetaMap(overwriteLightRef, lightFieldMetaMap);
442
+ }
443
+ setFieldMetaMap(modelRef, new Map([...modelFieldMetaMap, ...lightFieldMetaMap]));
444
+ return modelRef;
445
+ };
446
+ var via = (modelRef, fieldsOrLightModelRef, overwriteRef, overwriteLightRef) => {
447
+ if (!fieldsOrLightModelRef)
448
+ return baseModelOf(modelRef);
449
+ else if (Array.isArray(fieldsOrLightModelRef))
450
+ return lightModelOf(modelRef, fieldsOrLightModelRef);
451
+ else
452
+ return fullModelOf(modelRef, fieldsOrLightModelRef, overwriteRef, overwriteLightRef);
453
+ };
454
+ var addModelOf = (modelRef, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10) => {
455
+ const modelMetadataMap = getFieldMetaMap(modelRef);
456
+ const metadataMap = new Map(
457
+ [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10].filter((t) => !!t).reduce((acc, writeRef) => {
458
+ const writeMetadataMap = getFieldMetaMap(writeRef);
459
+ (0, import_common.applyMixins)(modelRef, [writeRef]);
460
+ return new Map([...acc, ...writeMetadataMap]);
461
+ }, modelMetadataMap)
462
+ );
463
+ setFieldMetaMap(modelRef, metadataMap);
464
+ return modelRef;
465
+ };
466
+ var addFilterOf = (filterRef, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10) => {
467
+ const filterMeta = getFilterMeta(filterRef);
468
+ const filterQueryMap = getFilterQueryMap(filterRef);
469
+ const metadataMap = new Map(
470
+ [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10].filter((t) => !!t).reduce((acc, writeRef) => {
471
+ const writeMetadataMap = getFilterQueryMap(writeRef);
472
+ (0, import_common.applyMixins)(filterRef, [writeRef]);
473
+ writeMetadataMap.forEach((value, key) => {
474
+ const filterArgMetas = getFilterArgMetas(writeRef, key);
475
+ setFilterArgMetasOnPrototype(filterRef.prototype, key, filterArgMetas);
499
476
  });
500
- });
501
- };
502
-
503
- // pkgs/@akanjs/common/src/capitalize.ts
504
- var capitalize = (str) => {
505
- return str.charAt(0).toUpperCase() + str.slice(1);
506
- };
507
-
508
- // pkgs/@akanjs/common/src/Logger.ts
509
- var import_dayjs5 = __toESM(__require("dayjs"));
510
- var logLevels = ["trace", "verbose", "debug", "log", "info", "warn", "error"];
511
- var clc = {
512
- bold: (text) => `\x1B[1m${text}\x1B[0m`,
513
- green: (text) => `\x1B[32m${text}\x1B[39m`,
514
- yellow: (text) => `\x1B[33m${text}\x1B[39m`,
515
- red: (text) => `\x1B[31m${text}\x1B[39m`,
516
- magentaBright: (text) => `\x1B[95m${text}\x1B[39m`,
517
- cyanBright: (text) => `\x1B[96m${text}\x1B[39m`
518
- };
519
- var colorizeMap = {
520
- trace: clc.bold,
521
- verbose: clc.cyanBright,
522
- debug: clc.magentaBright,
523
- log: clc.green,
524
- info: clc.green,
525
- warn: clc.yellow,
526
- error: clc.red
527
- };
528
- var Logger = class _Logger {
529
- static #ignoreCtxSet = /* @__PURE__ */ new Set([
530
- "InstanceLoader",
531
- "RoutesResolver",
532
- "RouterExplorer",
533
- "NestFactory",
534
- "WebSocketsController",
535
- "GraphQLModule",
536
- "NestApplication"
537
- ]);
538
- static level = process.env.NEXT_PUBLIC_LOG_LEVEL ?? "log";
539
- static #levelIdx = logLevels.findIndex((l) => l === process.env.NEXT_PUBLIC_LOG_LEVEL);
540
- static #startAt = (0, import_dayjs5.default)();
541
- static setLevel(level) {
542
- this.level = level;
543
- this.#levelIdx = logLevels.findIndex((l) => l === level);
544
- }
545
- name;
546
- constructor(name) {
547
- this.name = name;
548
- }
549
- trace(msg, context = "") {
550
- if (_Logger.#levelIdx <= 0)
551
- _Logger.#printMessages(this.name ?? "App", msg, context, "trace");
552
- }
553
- verbose(msg, context = "") {
554
- if (_Logger.#levelIdx <= 1)
555
- _Logger.#printMessages(this.name ?? "App", msg, context, "verbose");
556
- }
557
- debug(msg, context = "") {
558
- if (_Logger.#levelIdx <= 2)
559
- _Logger.#printMessages(this.name ?? "App", msg, context, "debug");
560
- }
561
- log(msg, context = "") {
562
- if (_Logger.#levelIdx <= 3)
563
- _Logger.#printMessages(this.name ?? "App", msg, context, "log");
564
- }
565
- info(msg, context = "") {
566
- if (_Logger.#levelIdx <= 4)
567
- _Logger.#printMessages(this.name ?? "App", msg, context, "info");
568
- }
569
- warn(msg, context = "") {
570
- if (_Logger.#levelIdx <= 5)
571
- _Logger.#printMessages(this.name ?? "App", msg, context, "warn");
572
- }
573
- error(msg, context = "") {
574
- if (_Logger.#levelIdx <= 6)
575
- _Logger.#printMessages(this.name ?? "App", msg, context, "error");
576
- }
577
- raw(msg, method) {
578
- _Logger.rawLog(msg, method);
579
- }
580
- rawLog(msg, method) {
581
- _Logger.rawLog(msg, method);
582
- }
583
- static trace(msg, context = "") {
584
- if (_Logger.#levelIdx <= 0)
585
- _Logger.#printMessages("App", msg, context, "trace");
586
- }
587
- static verbose(msg, context = "") {
588
- if (_Logger.#levelIdx <= 1)
589
- _Logger.#printMessages("App", msg, context, "verbose");
590
- }
591
- static debug(msg, context = "") {
592
- if (_Logger.#levelIdx <= 2)
593
- _Logger.#printMessages("App", msg, context, "debug");
594
- }
595
- static log(msg, context = "") {
596
- if (_Logger.#levelIdx <= 3)
597
- _Logger.#printMessages("App", msg, context, "log");
598
- }
599
- static info(msg, context = "") {
600
- if (_Logger.#levelIdx <= 4)
601
- _Logger.#printMessages("App", msg, context, "info");
602
- }
603
- static warn(msg, context = "") {
604
- if (_Logger.#levelIdx <= 5)
605
- _Logger.#printMessages("App", msg, context, "warn");
606
- }
607
- static error(msg, context = "") {
608
- if (_Logger.#levelIdx <= 6)
609
- _Logger.#printMessages("App", msg, context, "error");
610
- }
611
- static #colorize(msg, logLevel) {
612
- return colorizeMap[logLevel](msg);
613
- }
614
- static #printMessages(name, content, context, logLevel, writeStreamType = logLevel === "error" ? "stderr" : "stdout") {
615
- if (this.#ignoreCtxSet.has(context))
616
- return;
617
- const now = (0, import_dayjs5.default)();
618
- const processMsg = this.#colorize(
619
- `[${name ?? "App"}] ${global.process?.pid ?? "window"} -`,
620
- logLevel
621
- );
622
- const timestampMsg = now.format("MM/DD/YYYY, HH:mm:ss A");
623
- const logLevelMsg = this.#colorize(logLevel.toUpperCase().padStart(7, " "), logLevel);
624
- const contextMsg = context ? clc.yellow(`[${context}] `) : "";
625
- const contentMsg = this.#colorize(content, logLevel);
626
- const timeDiffMsg = clc.yellow(`+${now.diff(_Logger.#startAt, "ms")}ms`);
627
- if (typeof window === "undefined")
628
- process[writeStreamType].write(
629
- `${processMsg} ${timestampMsg} ${logLevelMsg} ${contextMsg} ${contentMsg} ${timeDiffMsg}
630
- `
631
- );
632
- else
633
- console.log(`${processMsg} ${timestampMsg} ${logLevelMsg} ${contextMsg} ${contentMsg} ${timeDiffMsg}
634
- `);
635
- }
636
- static rawLog(msg, method) {
637
- this.raw(`${msg}
638
- `, method);
639
- }
640
- static raw(msg, method) {
641
- if (typeof window === "undefined" && method !== "console" && global.process)
642
- global.process.stdout.write(msg);
643
- else
644
- console.log(msg);
645
- }
646
- };
647
-
648
- // pkgs/@akanjs/constant/src/baseGql.ts
649
- var defaultFieldMeta = {
650
- fieldType: "property",
651
- immutable: false,
652
- select: true,
653
- isClass: false,
654
- isScalar: true,
655
- nullable: false,
656
- isArray: false,
657
- arrDepth: 0,
658
- optArrDepth: 0,
659
- default: null,
660
- isMap: false
661
- };
662
- var idFieldMeta = { ...defaultFieldMeta, key: "id", name: "ID", modelRef: ID };
663
- var createdAtFieldMeta = { ...defaultFieldMeta, key: "createdAt", name: "Date", modelRef: Date };
664
- var updatedAtFieldMeta = { ...defaultFieldMeta, key: "updatedAt", name: "Date", modelRef: Date };
665
- var removedAtFieldMeta = {
666
- ...defaultFieldMeta,
667
- key: "removedAt",
668
- name: "Date",
669
- modelRef: Date,
670
- nullable: true,
671
- default: null
672
- };
673
- var extendModel = (modelRef) => {
674
- class BaseModel {
675
- }
676
- const metadataMap = getFieldMetaMap(modelRef);
677
- setFieldMetaMap(BaseModel, metadataMap);
678
- return BaseModel;
679
- };
680
- var as = extendModel;
681
- var baseModelOf = (modelRef) => {
682
- class BaseModel {
683
- __ModelType__ = "full";
684
- }
685
- const metadataMap = getFieldMetaMap(modelRef);
686
- metadataMap.set("id", idFieldMeta);
687
- metadataMap.set("createdAt", createdAtFieldMeta);
688
- metadataMap.set("updatedAt", updatedAtFieldMeta);
689
- metadataMap.set("removedAt", removedAtFieldMeta);
690
- Reflect.defineMetadata("fields", metadataMap, BaseModel.prototype);
691
- return BaseModel;
692
- };
693
- var lightModelOf = (objectRef, fields) => {
694
- const map = /* @__PURE__ */ new Map();
695
- const metadataMap = getFieldMetaMap(objectRef);
696
- class BaseGql {
697
- __ModelType__ = "light";
698
- }
699
- ["id", ...fields, "createdAt", "updatedAt", "removedAt"].forEach((key) => map.set(key, metadataMap.get(key)));
700
- Reflect.defineMetadata("fields", map, BaseGql.prototype);
701
- return BaseGql;
702
- };
703
- var fullModelOf = (modelRef, lightRef, overwriteRef, overwriteLightRef) => {
704
- const modelFieldMetaMap = getFieldMetaMap(modelRef);
705
- const lightFieldMetaMap = getFieldMetaMap(lightRef);
706
- applyMixins(modelRef, [lightRef]);
707
- if (overwriteRef) {
708
- applyMixins(overwriteRef, [modelRef]);
709
- setFieldMetaMap(overwriteRef, modelFieldMetaMap);
710
- }
711
- if (overwriteLightRef) {
712
- applyMixins(overwriteLightRef, [lightRef]);
713
- setFieldMetaMap(overwriteLightRef, lightFieldMetaMap);
714
- }
715
- setFieldMetaMap(modelRef, new Map([...modelFieldMetaMap, ...lightFieldMetaMap]));
716
- return modelRef;
717
- };
718
- var via = (modelRef, fieldsOrLightModelRef, overwriteRef, overwriteLightRef) => {
719
- if (!fieldsOrLightModelRef)
720
- return baseModelOf(modelRef);
721
- else if (Array.isArray(fieldsOrLightModelRef))
722
- return lightModelOf(modelRef, fieldsOrLightModelRef);
723
- else
724
- return fullModelOf(modelRef, fieldsOrLightModelRef, overwriteRef, overwriteLightRef);
725
- };
726
- var addModelOf = (modelRef, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10) => {
727
- const modelMetadataMap = getFieldMetaMap(modelRef);
728
- const metadataMap = new Map(
729
- [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10].filter((t) => !!t).reduce((acc, writeRef) => {
730
- const writeMetadataMap = getFieldMetaMap(writeRef);
731
- applyMixins(modelRef, [writeRef]);
732
- return new Map([...acc, ...writeMetadataMap]);
733
- }, modelMetadataMap)
734
- );
735
- setFieldMetaMap(modelRef, metadataMap);
736
- return modelRef;
737
- };
738
- var addFilterOf = (filterRef, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10) => {
739
- const filterMeta = getFilterMeta(filterRef);
740
- const filterQueryMap = getFilterQueryMap(filterRef);
741
- const metadataMap = new Map(
742
- [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10].filter((t) => !!t).reduce((acc, writeRef) => {
743
- const writeMetadataMap = getFilterQueryMap(writeRef);
744
- applyMixins(filterRef, [writeRef]);
745
- writeMetadataMap.forEach((value, key) => {
746
- const filterArgMetas = getFilterArgMetas(writeRef, key);
747
- setFilterArgMetasOnPrototype(filterRef.prototype, key, filterArgMetas);
748
- });
749
- return new Map([...acc, ...writeMetadataMap]);
750
- }, filterQueryMap)
751
- );
752
- const filterSort = [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10].filter((t) => !!t).map((t) => getFilterSortMap(t)).reduce((acc, sort) => {
753
- Object.assign(acc, sort);
754
- return acc;
755
- }, filterMeta.sort);
756
- setFilterKeyMetaMapOnPrototype(filterRef.prototype, metadataMap);
757
- setFilterMeta(filterRef, { ...filterMeta, sort: filterSort });
758
- return filterRef;
759
- };
760
- var from = (modelRef, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10) => {
761
- if (isConstantModel(modelRef))
762
- return addModelOf(modelRef, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);
763
- else if (isFilterModel(modelRef))
764
- return addFilterOf(modelRef, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);
765
- else
766
- throw new Error("Invalid modelRef");
767
- };
768
- var mixModelOf = (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20) => {
769
- class Mix {
770
- }
771
- const metadataMap = new Map(
772
- [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20].filter((t) => !!t).reduce((acc, modelRef) => {
773
- const modelMetadataMap = getFieldMetaMap(modelRef);
774
- applyMixins(Mix, [modelRef]);
775
- return [...acc, ...modelMetadataMap];
776
- }, [])
777
- );
778
- setFieldMetaMap(Mix, metadataMap);
779
- return Mix;
780
- };
781
- var over = mixModelOf;
477
+ return new Map([...acc, ...writeMetadataMap]);
478
+ }, filterQueryMap)
479
+ );
480
+ const filterSort = [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10].filter((t) => !!t).map((t) => getFilterSortMap(t)).reduce((acc, sort) => {
481
+ Object.assign(acc, sort);
482
+ return acc;
483
+ }, filterMeta.sort);
484
+ setFilterKeyMetaMapOnPrototype(filterRef.prototype, metadataMap);
485
+ setFilterMeta(filterRef, { ...filterMeta, sort: filterSort });
486
+ return filterRef;
487
+ };
488
+ var from = (modelRef, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10) => {
489
+ if (isConstantModel(modelRef))
490
+ return addModelOf(modelRef, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);
491
+ else if (isFilterModel(modelRef))
492
+ return addFilterOf(modelRef, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);
493
+ else
494
+ throw new Error("Invalid modelRef");
495
+ };
496
+ var mixModelOf = (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20) => {
497
+ class Mix {
498
+ }
499
+ const metadataMap = new Map(
500
+ [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20].filter((t) => !!t).reduce((acc, modelRef) => {
501
+ const modelMetadataMap = getFieldMetaMap(modelRef);
502
+ (0, import_common.applyMixins)(Mix, [modelRef]);
503
+ return [...acc, ...modelMetadataMap];
504
+ }, [])
505
+ );
506
+ setFieldMetaMap(Mix, metadataMap);
507
+ return Mix;
508
+ };
509
+ var over = mixModelOf;
782
510
 
783
- // pkgs/@akanjs/constant/src/classMeta.ts
784
- var import_reflect_metadata4 = __require("reflect-metadata");
785
- var InputModelStorage = class {
786
- };
787
- var LightModelStorage = class {
788
- };
789
- var FullModelStorage = class {
790
- };
791
- var ScalarModelStorage = class {
792
- };
793
- var FilterModelStorage = class {
794
- };
795
- var getFullModelRef = (refName) => {
796
- const modelRef = Reflect.getMetadata(capitalize(refName), FullModelStorage.prototype);
797
- if (!modelRef)
798
- throw new Error(`FullModel not found - ${refName}`);
799
- return modelRef;
800
- };
801
- var getInputModelRef = (refName) => {
802
- const modelRef = Reflect.getMetadata(capitalize(refName), InputModelStorage.prototype);
803
- if (!modelRef)
804
- throw new Error(`InputModel not found - ${refName}`);
805
- return modelRef;
806
- };
807
- var getScalarModelRef = (refName) => {
808
- const modelRef = Reflect.getMetadata(capitalize(refName), ScalarModelStorage.prototype);
809
- if (!modelRef)
810
- throw new Error(`ScalarModel not found - ${refName}`);
811
- return modelRef;
812
- };
813
- var getChildClassRefs = (target) => {
814
- const metadatas = getFieldMetas(target);
815
- const refMap = /* @__PURE__ */ new Map();
816
- const childRefs = metadatas.filter((metadata) => metadata.isClass).reduce((acc, metadata) => {
817
- return [...acc, metadata.modelRef, ...getChildClassRefs(metadata.modelRef)];
818
- }, []);
819
- childRefs.filter((modelRef, idx) => childRefs.findIndex((ref) => ref.prototype === modelRef.prototype) === idx).map((modelRef) => refMap.set(getClassMeta(modelRef).refName, modelRef));
820
- return [...refMap.values()];
821
- };
822
- var getFieldEnumMetas = (modelRef) => {
823
- const fieldMetas = getFieldMetas(modelRef);
824
- return fieldMetas.filter((fieldMeta) => !!fieldMeta.enum).map((fieldMeta) => ({ key: fieldMeta.key, enum: fieldMeta.enum }));
825
- };
826
- var hasTextField = (modelRef) => {
827
- const fieldMetas = getFieldMetas(modelRef);
828
- return fieldMetas.some(
829
- (fieldMeta) => !!fieldMeta.text || fieldMeta.isScalar && fieldMeta.isClass && fieldMeta.select && hasTextField(fieldMeta.modelRef)
830
- );
831
- };
832
- var applyClassMeta = (type, modelType, storage) => {
833
- return function(refName) {
834
- return function(target) {
835
- const modelRef = target;
836
- const classMeta = { refName, type, modelType, modelRef, hasTextField: hasTextField(modelRef) };
837
- Reflect.defineMetadata("class", classMeta, modelRef.prototype);
838
- Reflect.defineMetadata(refName, modelRef, storage.prototype);
839
- };
511
+ // pkgs/@akanjs/constant/src/classMeta.ts
512
+ var import_reflect_metadata4 = require("reflect-metadata");
513
+ var import_common2 = require("@akanjs/common");
514
+ var InputModelStorage = class {
515
+ };
516
+ var LightModelStorage = class {
517
+ };
518
+ var FullModelStorage = class {
519
+ };
520
+ var ScalarModelStorage = class {
521
+ };
522
+ var FilterModelStorage = class {
523
+ };
524
+ var getFullModelRef = (refName) => {
525
+ const modelRef = Reflect.getMetadata((0, import_common2.capitalize)(refName), FullModelStorage.prototype);
526
+ if (!modelRef)
527
+ throw new Error(`FullModel not found - ${refName}`);
528
+ return modelRef;
529
+ };
530
+ var getInputModelRef = (refName) => {
531
+ const modelRef = Reflect.getMetadata((0, import_common2.capitalize)(refName), InputModelStorage.prototype);
532
+ if (!modelRef)
533
+ throw new Error(`InputModel not found - ${refName}`);
534
+ return modelRef;
535
+ };
536
+ var getScalarModelRef = (refName) => {
537
+ const modelRef = Reflect.getMetadata((0, import_common2.capitalize)(refName), ScalarModelStorage.prototype);
538
+ if (!modelRef)
539
+ throw new Error(`ScalarModel not found - ${refName}`);
540
+ return modelRef;
541
+ };
542
+ var getChildClassRefs = (target) => {
543
+ const metadatas = getFieldMetas(target);
544
+ const refMap = /* @__PURE__ */ new Map();
545
+ const childRefs = metadatas.filter((metadata) => metadata.isClass).reduce((acc, metadata) => {
546
+ return [...acc, metadata.modelRef, ...getChildClassRefs(metadata.modelRef)];
547
+ }, []);
548
+ childRefs.filter((modelRef, idx) => childRefs.findIndex((ref) => ref.prototype === modelRef.prototype) === idx).map((modelRef) => refMap.set(getClassMeta(modelRef).refName, modelRef));
549
+ return [...refMap.values()];
550
+ };
551
+ var getFieldEnumMetas = (modelRef) => {
552
+ const fieldMetas = getFieldMetas(modelRef);
553
+ return fieldMetas.filter((fieldMeta) => !!fieldMeta.enum).map((fieldMeta) => ({ key: fieldMeta.key, enum: fieldMeta.enum }));
554
+ };
555
+ var hasTextField = (modelRef) => {
556
+ const fieldMetas = getFieldMetas(modelRef);
557
+ return fieldMetas.some(
558
+ (fieldMeta) => !!fieldMeta.text || fieldMeta.isScalar && fieldMeta.isClass && fieldMeta.select && hasTextField(fieldMeta.modelRef)
559
+ );
560
+ };
561
+ var applyClassMeta = (type, modelType, storage) => {
562
+ return function(refName) {
563
+ return function(target) {
564
+ const modelRef = target;
565
+ const classMeta = { refName, type, modelType, modelRef, hasTextField: hasTextField(modelRef) };
566
+ Reflect.defineMetadata("class", classMeta, modelRef.prototype);
567
+ Reflect.defineMetadata(refName, modelRef, storage.prototype);
840
568
  };
841
569
  };
842
- var applyFilterMeta = (storage) => {
843
- return function(refName) {
844
- return function(target) {
845
- const modelRef = target;
846
- setFilterMeta(modelRef, { refName, sort: {} });
847
- Reflect.defineMetadata(refName, modelRef, storage.prototype);
848
- };
570
+ };
571
+ var applyFilterMeta = (storage) => {
572
+ return function(refName) {
573
+ return function(target) {
574
+ const modelRef = target;
575
+ setFilterMeta(modelRef, { refName, sort: {} });
576
+ Reflect.defineMetadata(refName, modelRef, storage.prototype);
849
577
  };
850
578
  };
851
- var Model = {
852
- Light: applyClassMeta("light", "data", LightModelStorage),
853
- Object: applyClassMeta("full", "ephemeral", FullModelStorage),
854
- Full: applyClassMeta("full", "data", FullModelStorage),
855
- Input: applyClassMeta("input", "data", InputModelStorage),
856
- Scalar: applyClassMeta("scalar", "data", ScalarModelStorage),
857
- Summary: applyClassMeta("scalar", "summary", ScalarModelStorage),
858
- Insight: applyClassMeta("scalar", "insight", ScalarModelStorage),
859
- Filter: applyFilterMeta(FilterModelStorage)
860
- };
861
- var getLightModelRef = (modelRef) => {
862
- const classMeta = getClassMeta(modelRef);
863
- if (classMeta.type !== "full")
864
- return modelRef;
865
- const lightModelRef = Reflect.getMetadata(`Light${classMeta.refName}`, LightModelStorage.prototype);
866
- if (!lightModelRef)
867
- throw new Error(`LightModel not found - ${classMeta.refName}`);
868
- return lightModelRef;
869
- };
870
- var getAllFullModelRefs = () => {
871
- const modelNames = Reflect.getMetadataKeys(FullModelStorage.prototype);
872
- const modelRefs = modelNames.map(
873
- (modelName) => Reflect.getMetadata(modelName, FullModelStorage.prototype)
874
- );
875
- return modelRefs;
876
- };
877
- var getAllScalarModelRefs = () => {
878
- const modelNames = Reflect.getMetadataKeys(ScalarModelStorage.prototype);
879
- const modelRefs = modelNames.map(
880
- (modelName) => Reflect.getMetadata(modelName, ScalarModelStorage.prototype)
881
- );
882
- return modelRefs;
883
- };
884
- var getAllFilterModelRefs = () => {
885
- const modelNames = Reflect.getMetadataKeys(FilterModelStorage.prototype);
886
- const modelRefs = modelNames.map(
887
- (modelName) => Reflect.getMetadata(modelName, FilterModelStorage.prototype)
888
- );
889
- return modelRefs;
890
- };
891
- })();
892
- //! Nextjs는 환경변수를 build time에 그냥 하드코딩으로 값을 넣어버림. operationMode같은것들 잘 동작안할 수 있음. 추후 수정 필요.
579
+ };
580
+ var Model = {
581
+ Light: applyClassMeta("light", "data", LightModelStorage),
582
+ Object: applyClassMeta("full", "ephemeral", FullModelStorage),
583
+ Full: applyClassMeta("full", "data", FullModelStorage),
584
+ Input: applyClassMeta("input", "data", InputModelStorage),
585
+ Scalar: applyClassMeta("scalar", "data", ScalarModelStorage),
586
+ Summary: applyClassMeta("scalar", "summary", ScalarModelStorage),
587
+ Insight: applyClassMeta("scalar", "insight", ScalarModelStorage),
588
+ Filter: applyFilterMeta(FilterModelStorage)
589
+ };
590
+ var getLightModelRef = (modelRef) => {
591
+ const classMeta = getClassMeta(modelRef);
592
+ if (classMeta.type !== "full")
593
+ return modelRef;
594
+ const lightModelRef = Reflect.getMetadata(`Light${classMeta.refName}`, LightModelStorage.prototype);
595
+ if (!lightModelRef)
596
+ throw new Error(`LightModel not found - ${classMeta.refName}`);
597
+ return lightModelRef;
598
+ };
599
+ var getAllFullModelRefs = () => {
600
+ const modelNames = Reflect.getMetadataKeys(FullModelStorage.prototype);
601
+ const modelRefs = modelNames.map(
602
+ (modelName) => Reflect.getMetadata(modelName, FullModelStorage.prototype)
603
+ );
604
+ return modelRefs;
605
+ };
606
+ var getAllScalarModelRefs = () => {
607
+ const modelNames = Reflect.getMetadataKeys(ScalarModelStorage.prototype);
608
+ const modelRefs = modelNames.map(
609
+ (modelName) => Reflect.getMetadata(modelName, ScalarModelStorage.prototype)
610
+ );
611
+ return modelRefs;
612
+ };
613
+ var getAllFilterModelRefs = () => {
614
+ const modelNames = Reflect.getMetadataKeys(FilterModelStorage.prototype);
615
+ const modelRefs = modelNames.map(
616
+ (modelName) => Reflect.getMetadata(modelName, FilterModelStorage.prototype)
617
+ );
618
+ return modelRefs;
619
+ };