@akanjs/constant 0.0.39 → 0.0.40

package/src/scalar.js

@@ -0,0 +1,141 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var scalar_exports = {};
+__export(scalar_exports, {
+  fieldTypes: () => fieldTypes,
+  getClassMeta: () => getClassMeta,
+  getFieldMetaMap: () => getFieldMetaMap,
+  getFieldMetaMapOnPrototype: () => getFieldMetaMapOnPrototype,
+  getFieldMetas: () => getFieldMetas,
+  getGqlTypeStr: () => getGqlTypeStr,
+  getQueryMap: () => getQueryMap,
+  getScalarExample: () => getScalarExample,
+  isConstantModel: () => isConstantModel,
+  scalarExampleMap: () => scalarExampleMap,
+  setFieldMetaMap: () => setFieldMetaMap,
+  setFieldMetaMapOnPrototype: () => setFieldMetaMapOnPrototype
+});
+module.exports = __toCommonJS(scalar_exports);
+var import_reflect_metadata = require("reflect-metadata");
+var import_base = require("@akanjs/base");
+const scalarExampleMap = /* @__PURE__ */ new Map([
+  [
+    import_base.ID,
+    "1234567890abcdef12345678"
+  ],
+  [
+    import_base.Int,
+    0
+  ],
+  [
+    import_base.Float,
+    0
+  ],
+  [
+    String,
+    "String"
+  ],
+  [
+    Boolean,
+    true
+  ],
+  [
+    Date,
+    (/* @__PURE__ */ new Date()).toISOString()
+  ],
+  [
+    import_base.Upload,
+    "FileUpload"
+  ],
+  [
+    import_base.JSON,
+    {}
+  ],
+  [
+    Map,
+    {}
+  ]
+]);
+const getScalarExample = /* @__PURE__ */ __name((ref) => scalarExampleMap.get(ref) ?? null, "getScalarExample");
+const getGqlTypeStr = /* @__PURE__ */ __name((ref) => import_base.scalarNameMap.get(ref) ?? getClassMeta(ref).refName, "getGqlTypeStr");
+const fieldTypes = [
+  "email",
+  "password",
+  "url"
+];
+const getClassMeta = /* @__PURE__ */ __name((modelRef) => {
+  const [target] = (0, import_base.getNonArrayModel)(modelRef);
+  const classMeta = Reflect.getMetadata("class", target.prototype);
+  if (!classMeta) throw new Error(`No ClassMeta for this target ${target.name}`);
+  return classMeta;
+}, "getClassMeta");
+const getFieldMetas = /* @__PURE__ */ __name((modelRef) => {
+  const [target] = (0, import_base.getNonArrayModel)(modelRef);
+  const metadataMap = Reflect.getMetadata("fields", target.prototype) ?? /* @__PURE__ */ new Map();
+  const keySortMap = {
+    id: -1,
+    createdAt: 1,
+    updatedAt: 2,
+    removedAt: 3
+  };
+  return [
+    ...metadataMap.values()
+  ].sort((a, b) => (keySortMap[a.key] ?? 0) - (keySortMap[b.key] ?? 0));
+}, "getFieldMetas");
+const isConstantModel = /* @__PURE__ */ __name((modelRef) => {
+  return Reflect.getMetadata("class", modelRef.prototype) !== void 0;
+}, "isConstantModel");
+const getFieldMetaMap = /* @__PURE__ */ __name((modelRef) => {
+  const [target] = (0, import_base.getNonArrayModel)(modelRef);
+  const metadataMap = Reflect.getMetadata("fields", target.prototype) ?? /* @__PURE__ */ new Map();
+  return new Map(metadataMap);
+}, "getFieldMetaMap");
+const setFieldMetaMap = /* @__PURE__ */ __name((modelRef, metadataMap) => {
+  const [target] = (0, import_base.getNonArrayModel)(modelRef);
+  Reflect.defineMetadata("fields", new Map(metadataMap), target.prototype);
+}, "setFieldMetaMap");
+const getFieldMetaMapOnPrototype = /* @__PURE__ */ __name((prototype) => {
+  const metadataMap = Reflect.getMetadata("fields", prototype) ?? /* @__PURE__ */ new Map();
+  return new Map(metadataMap);
+}, "getFieldMetaMapOnPrototype");
+const setFieldMetaMapOnPrototype = /* @__PURE__ */ __name((prototype, metadataMap) => {
+  Reflect.defineMetadata("fields", new Map(metadataMap), prototype);
+}, "setFieldMetaMapOnPrototype");
+const getQueryMap = /* @__PURE__ */ __name((modelRef) => {
+  const fieldMetas = getFieldMetas(modelRef);
+  return Object.fromEntries(fieldMetas.filter((fieldMeta) => !!fieldMeta.query).map((fieldMeta) => [
+    fieldMeta.key,
+    fieldMeta.query
+  ]));
+}, "getQueryMap");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fieldTypes,
+  getClassMeta,
+  getFieldMetaMap,
+  getFieldMetaMapOnPrototype,
+  getFieldMetas,
+  getGqlTypeStr,
+  getQueryMap,
+  getScalarExample,
+  isConstantModel,
+  scalarExampleMap,
+  setFieldMetaMap,
+  setFieldMetaMapOnPrototype
+});

package/src/types.d.ts

@@ -0,0 +1,6 @@
+export { i as DEFAULT_PAGE_SIZE, D as DocumentModel, F as FilterType, b as FindQueryOption, f as GetActionObject, G as GetPlainObject, e as GetStateObject, c as ListOption, L as ListQueryOption, N as NonFunctionalKeys, g as ProtoAppInfo, P as ProtoFile, h as ProtoPatch, a as SortOf, S as SortType, T as TextDoc, d as defaultListOption } from '../types-DdO4B_Um.js';
+export { FilterQuery as QueryOf } from 'mongoose';
+import 'dayjs';
+import 'fs';
+import 'stream';
+import '../types-b-U-yQib.js';

package/src/types.js

@@ -0,0 +1,34 @@
+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 types_exports = {};
+__export(types_exports, {
+  DEFAULT_PAGE_SIZE: () => DEFAULT_PAGE_SIZE,
+  defaultListOption: () => defaultListOption
+});
+module.exports = __toCommonJS(types_exports);
+const defaultListOption = {
+  limit: 20,
+  skip: 0,
+  sort: "latest"
+};
+const DEFAULT_PAGE_SIZE = 20;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_PAGE_SIZE,
+  defaultListOption
+});

package/types-DdO4B_Um.d.ts

@@ -0,0 +1,126 @@
+import { Dayjs } from 'dayjs';
+import { ReadStream } from 'fs';
+import { Readable } from 'stream';
+import { T as Type, G as GraphQLJSON, a as GraphQLUpload } from './types-b-U-yQib.js';
+import { ProjectionType, HydratedDocument } from 'mongoose';
+
+declare class BaseObject {
+    id: string;
+    createdAt: Dayjs;
+    updatedAt: Dayjs;
+    removedAt: Dayjs | null;
+}
+declare class Int {
+    __Scalar__: "int";
+}
+declare class Upload {
+    __Scalar__: "upload";
+    filename: string;
+    mimetype: string;
+    encoding: string;
+    createReadStream: () => ReadStream | Readable;
+}
+declare class Float {
+    __Scalar__: "float";
+}
+declare class ID {
+    __Scalar__: "id";
+}
+declare class JSON {
+    __Scalar__: "json";
+}
+type SingleFieldType = Int | Float | StringConstructor | BooleanConstructor | ID | DateConstructor | JSON | Type | GraphQLJSON | GraphQLUpload;
+declare const gqlScalars: readonly [StringConstructor, BooleanConstructor, DateConstructor, typeof ID, typeof Int, typeof Float, typeof Upload, typeof JSON, MapConstructor];
+type GqlScalar = (typeof gqlScalars)[number];
+
+type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
+type OptionalKeys<T> = T extends {
+    [key: string]: any;
+} ? {
+    [K in keyof T]-?: null extends T[K] ? K : never;
+}[keyof T] : never;
+type ObjectToId<O, D = Dayjs> = O extends BaseObject ? string : O extends BaseObject[] ? string[] : O extends Dayjs ? D : O extends {
+    [key: string]: any;
+} ? DocumentModel<O> : O;
+interface SortType {
+    [key: string]: {
+        [key: string]: number;
+    };
+}
+type SortOf<Filter> = keyof GetStateObject<Filter>;
+type FilterType = Record<string, any>;
+interface ListQueryOption<Sort, Obj> {
+    skip?: number | null;
+    limit?: number | null;
+    sort?: Sort | null;
+    sample?: number;
+    select?: ProjectionType<Obj>;
+}
+interface FindQueryOption<Sort, Obj> {
+    skip?: number | null;
+    sort?: Sort | null;
+    sample?: boolean;
+    select?: ProjectionType<Obj>;
+}
+type DocumentModel<T, D = Dayjs> = T extends (infer S)[] ? DocumentModel<S>[] : T extends string ? T : T extends number ? T : T extends boolean ? T : T extends Dayjs ? T : T extends Map<infer K, infer V> ? Map<K, DocumentModel<V, D>> : Optional<{
+    [K in keyof GetStateObject<T>]: T[K] extends infer S ? S extends null ? undefined : ObjectToId<T[K], D> : never;
+}, OptionalKeys<GetStateObject<T>>>;
+interface ListOption {
+    limit?: number;
+    skip?: number;
+    sort?: string;
+}
+declare const defaultListOption: ListOption;
+type GetPlainObject<T, O extends string> = Omit<{
+    [K in keyof T as T[K] extends (...args: any) => any ? never : K extends keyof HydratedDocument<any> ? never : K]: T[K];
+}, O>;
+type GetStateObject<T> = Omit<{
+    [K in keyof T as T[K] extends (...args: any) => any ? never : K]: T[K];
+}, "prototype">;
+type GetActionObject<T> = Omit<{
+    [K in keyof T as T[K] extends (...args: any) => any ? K : never]: T[K];
+}, "prototype">;
+interface ProtoFile {
+    id: string;
+    filename: string;
+    abstractData: string | null;
+    imageSize: [number, number];
+    progress: number | null;
+    url: string;
+    size: number;
+    status: string;
+    createdAt: Dayjs;
+    updatedAt: Dayjs;
+    removedAt: Dayjs | null;
+    mimetype: string;
+    encoding: string;
+    origin: string | null;
+    lastModifiedAt: Dayjs;
+}
+interface ProtoAppInfo {
+    appId: string | null;
+    appName: string;
+    deviceId: string | null;
+    platform: "ios" | "android" | null;
+    major: number;
+    minor: number;
+    patch: number;
+    branch: string;
+    buildNum: string | null;
+    versionOs: string | null;
+    isEmulator: boolean | null;
+}
+interface ProtoPatch {
+    source: ProtoFile;
+    build: ProtoFile;
+    appBuild: ProtoFile | null;
+    status: "active" | "expired";
+    at: Dayjs;
+}
+declare const DEFAULT_PAGE_SIZE = 20;
+interface TextDoc {
+    [key: string]: string | TextDoc;
+}
+type NonFunctionalKeys<T> = keyof T extends (...any: any[]) => any ? never : keyof T;
+
+export { BaseObject as B, type DocumentModel as D, type FilterType as F, type GetPlainObject as G, Int as I, JSON as J, type ListQueryOption as L, type NonFunctionalKeys as N, type ProtoFile as P, type SortType as S, type TextDoc as T, Upload as U, type SortOf as a, type FindQueryOption as b, type ListOption as c, defaultListOption as d, type GetStateObject as e, type GetActionObject as f, type ProtoAppInfo as g, type ProtoPatch as h, DEFAULT_PAGE_SIZE as i, type SingleFieldType as j, type GqlScalar as k, Float as l, ID as m };

package/types-b-U-yQib.d.ts

@@ -0,0 +1,33 @@
+type Type<T = any> = new (...args: any[]) => T;
+interface GraphQLUpload {
+    name: string;
+    description: string;
+    specifiedByUrl: string;
+    serialize: any;
+    parseValue: any;
+    parseLiteral: any;
+    extensions: any;
+    astNode: any;
+    extensionASTNodes: any;
+    toConfig(): any;
+    toString(): string;
+    toJSON(): string;
+    inspect(): string;
+}
+interface GraphQLJSON<TInternal = unknown, TExternal = TInternal> {
+    name: string;
+    description: string;
+    specifiedByURL: string;
+    serialize: any;
+    parseValue: any;
+    parseLiteral: any;
+    extensions: any;
+    astNode: any;
+    extensionASTNodes: any;
+    get [Symbol.toStringTag](): string;
+    toConfig(): any;
+    toString(): string;
+    toJSON(): string;
+}
+
+export type { GraphQLJSON as G, Type as T, GraphQLUpload as a };