@akanjs/test 0.0.40 → 0.0.41

package/index.d.ts

@@ -1,3 +1 @@
-export { sampleOf } from './src/sampleOf.js';
-export { sample } from './src/sample.js';
-import 'dayjs';
+export * from "./src";

package/index.js

@@ -1,21 +1,626 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-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 index_exports = {};
-module.exports = __toCommonJS(index_exports);
-__reExport(index_exports, require("./src"), module.exports);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ...require("./src")
-});
+(() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+  }) : x)(function(x) {
+    if (typeof require !== "undefined")
+      return require.apply(this, arguments);
+    throw Error('Dynamic require of "' + x + '" is not supported');
+  });
+  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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+
+  // pkgs/@akanjs/base/src/base.ts
+  var version = "0.9.0";
+  var logo = `
+     _    _                  _     
+    / \\  | | ____ _ _ __    (_)___ 
+   / _ \\ | |/ / _' | '_ \\   | / __|
+  / ___ \\|   < (_| | | | |_ | \\__ \\
+ /_/   \\_\\_|\\_\\__,_|_| |_(_)/ |___/
+                          |__/      ver ${version}
+? See more details on docs  https://www.akanjs.com/docs
+\u2605 Star Akanjs on GitHub     https://github.com/aka-bassman/akanjs
+
+`;
+
+  // pkgs/@akanjs/base/src/baseEnv.ts
+  var appName = process.env.NEXT_PUBLIC_APP_NAME ?? "unknown";
+  var repoName = process.env.NEXT_PUBLIC_REPO_NAME ?? "unknown";
+  var serveDomain = process.env.NEXT_PUBLIC_SERVE_DOMAIN ?? "unknown";
+  if (appName === "unknown")
+    throw new Error("environment variable NEXT_PUBLIC_APP_NAME is required");
+  if (repoName === "unknown")
+    throw new Error("environment variable NEXT_PUBLIC_REPO_NAME is required");
+  if (serveDomain === "unknown")
+    throw new Error("environment variable NEXT_PUBLIC_SERVE_DOMAIN is required");
+  var environment = process.env.NEXT_PUBLIC_ENV ?? "debug";
+  var operationType = typeof window !== "undefined" ? "client" : process.env.NEXT_RUNTIME ? "client" : "server";
+  var operationMode = process.env.NEXT_PUBLIC_OPERATION_MODE ?? "cloud";
+  var networkType = process.env.NEXT_PUBLIC_NETWORK_TYPE ?? (environment === "main" ? "mainnet" : environment === "develop" ? "testnet" : "debugnet");
+  var tunnelUsername = process.env.SSU_TUNNEL_USERNAME ?? "root";
+  var tunnelPassword = process.env.SSU_TUNNEL_PASSWORD ?? repoName;
+  var baseEnv = {
+    repoName,
+    serveDomain,
+    appName,
+    environment,
+    operationType,
+    operationMode,
+    networkType,
+    tunnelUsername,
+    tunnelPassword
+  };
+  var side = typeof window === "undefined" ? "server" : "client";
+  var renderMode = process.env.RENDER_ENV ?? "ssr";
+  var clientHost = process.env.NEXT_PUBLIC_CLIENT_HOST ?? (operationMode === "local" || side === "server" ? "localhost" : window.location.hostname);
+  var clientPort = parseInt(
+    process.env.NEXT_PUBLIC_CLIENT_PORT ?? (operationMode === "local" ? renderMode === "ssr" ? "4200" : "4201" : "443")
+  );
+  var clientHttpProtocol = side === "client" ? window.location.protocol : clientHost === "localhost" ? "http:" : "https:";
+  var clientHttpUri = `${clientHttpProtocol}//${clientHost}${clientPort === 443 ? "" : `:${clientPort}`}`;
+  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");
+  var serverPort = parseInt(
+    process.env.SERVER_PORT ?? (operationMode === "local" || side === "server" ? "8080" : "443")
+  );
+  var serverHttpProtocol = side === "client" ? window.location.protocol : "http:";
+  var serverHttpUri = `${serverHttpProtocol}//${serverHost}${serverPort === 443 ? "" : `:${serverPort}`}/backend`;
+  var serverGraphqlUri = `${serverHttpUri}/graphql`;
+  var serverWsProtocol = serverHttpProtocol === "http:" ? "ws:" : "wss:";
+  var serverWsUri = `${serverWsProtocol}//${serverHost}${serverPort === 443 ? "" : `:${serverPort}`}`;
+  var baseClientEnv = {
+    ...baseEnv,
+    side,
+    renderMode,
+    websocket: true,
+    clientHost,
+    clientPort,
+    clientHttpProtocol,
+    clientHttpUri,
+    serverHost,
+    serverPort,
+    serverHttpProtocol,
+    serverHttpUri,
+    serverGraphqlUri,
+    serverWsProtocol,
+    serverWsUri
+  };
+
+  // pkgs/@akanjs/base/src/scalar.ts
+  var import_dayjs = __toESM(__require("dayjs"));
+  var dayjs = import_dayjs.default;
+  var Int = class {
+    __Scalar__;
+  };
+  var Upload = class {
+    __Scalar__;
+    filename;
+    mimetype;
+    encoding;
+    createReadStream;
+  };
+  var Float = class {
+    __Scalar__;
+  };
+  var ID = class {
+    __Scalar__;
+  };
+  var JSON = class {
+    __Scalar__;
+  };
+  var getNonArrayModel = (arraiedModel) => {
+    let arrDepth = 0;
+    let target = arraiedModel;
+    while (Array.isArray(target)) {
+      target = target[0];
+      arrDepth++;
+    }
+    return [target, arrDepth];
+  };
+  var scalarSet = /* @__PURE__ */ new Set([String, Boolean, Date, ID, Int, Float, Upload, JSON, Map]);
+  var scalarNameMap = /* @__PURE__ */ new Map([
+    [ID, "ID"],
+    [Int, "Int"],
+    [Float, "Float"],
+    [String, "String"],
+    [Boolean, "Boolean"],
+    [Date, "Date"],
+    [Upload, "Upload"],
+    [JSON, "JSON"],
+    [Map, "Map"]
+  ]);
+  var scalarArgMap = /* @__PURE__ */ new Map([
+    [ID, null],
+    [String, ""],
+    [Boolean, false],
+    [Date, dayjs(/* @__PURE__ */ new Date(-1))],
+    [Int, 0],
+    [Float, 0],
+    [JSON, {}],
+    [Map, {}]
+  ]);
+  var scalarDefaultMap = /* @__PURE__ */ new Map([
+    [ID, null],
+    [String, ""],
+    [Boolean, false],
+    [Date, dayjs(/* @__PURE__ */ new Date(-1))],
+    [Int, 0],
+    [Float, 0],
+    [JSON, {}]
+  ]);
+  var isGqlScalar = (modelRef) => scalarSet.has(modelRef);
+  var isGqlMap = (modelRef) => modelRef === Map;
+
+  // pkgs/@akanjs/common/src/isDayjs.ts
+  var import_dayjs2 = __require("dayjs");
+
+  // pkgs/@akanjs/common/src/isQueryEqual.ts
+  var import_dayjs3 = __toESM(__require("dayjs"));
+
+  // pkgs/@akanjs/common/src/isValidDate.ts
+  var import_dayjs4 = __toESM(__require("dayjs"));
+  var import_customParseFormat = __toESM(__require("dayjs/plugin/customParseFormat"));
+  import_dayjs4.default.extend(import_customParseFormat.default);
+
+  // pkgs/@akanjs/common/src/randomPick.ts
+  var randomPick = (arr) => arr[Math.floor(Math.random() * arr.length)];
+
+  // pkgs/@akanjs/common/src/randomPicks.ts
+  var randomPicks = (arr, count = 1, allowDuplicate = false) => {
+    if (!allowDuplicate && arr.length <= count)
+      return arr;
+    const idxs = [];
+    let pickIdx;
+    for (let i = 0; i < count; i++) {
+      do {
+        pickIdx = Math.floor(Math.random() * arr.length);
+      } while (!allowDuplicate && idxs.includes(pickIdx));
+      idxs.push(pickIdx);
+    }
+    return idxs.map((idx) => arr[idx]);
+  };
+
+  // pkgs/@akanjs/common/src/pluralize.ts
+  var import_pluralize = __toESM(__require("pluralize"));
+
+  // pkgs/@akanjs/common/src/Logger.ts
+  var import_dayjs5 = __toESM(__require("dayjs"));
+  var logLevels = ["trace", "verbose", "debug", "log", "info", "warn", "error"];
+  var clc = {
+    bold: (text) => `\x1B[1m${text}\x1B[0m`,
+    green: (text) => `\x1B[32m${text}\x1B[39m`,
+    yellow: (text) => `\x1B[33m${text}\x1B[39m`,
+    red: (text) => `\x1B[31m${text}\x1B[39m`,
+    magentaBright: (text) => `\x1B[95m${text}\x1B[39m`,
+    cyanBright: (text) => `\x1B[96m${text}\x1B[39m`
+  };
+  var colorizeMap = {
+    trace: clc.bold,
+    verbose: clc.cyanBright,
+    debug: clc.magentaBright,
+    log: clc.green,
+    info: clc.green,
+    warn: clc.yellow,
+    error: clc.red
+  };
+  var Logger = class _Logger {
+    static #ignoreCtxSet = /* @__PURE__ */ new Set([
+      "InstanceLoader",
+      "RoutesResolver",
+      "RouterExplorer",
+      "NestFactory",
+      "WebSocketsController",
+      "GraphQLModule",
+      "NestApplication"
+    ]);
+    static level = process.env.NEXT_PUBLIC_LOG_LEVEL ?? "log";
+    static #levelIdx = logLevels.findIndex((l) => l === process.env.NEXT_PUBLIC_LOG_LEVEL);
+    static #startAt = (0, import_dayjs5.default)();
+    static setLevel(level) {
+      this.level = level;
+      this.#levelIdx = logLevels.findIndex((l) => l === level);
+    }
+    name;
+    constructor(name) {
+      this.name = name;
+    }
+    trace(msg, context = "") {
+      if (_Logger.#levelIdx <= 0)
+        _Logger.#printMessages(this.name ?? "App", msg, context, "trace");
+    }
+    verbose(msg, context = "") {
+      if (_Logger.#levelIdx <= 1)
+        _Logger.#printMessages(this.name ?? "App", msg, context, "verbose");
+    }
+    debug(msg, context = "") {
+      if (_Logger.#levelIdx <= 2)
+        _Logger.#printMessages(this.name ?? "App", msg, context, "debug");
+    }
+    log(msg, context = "") {
+      if (_Logger.#levelIdx <= 3)
+        _Logger.#printMessages(this.name ?? "App", msg, context, "log");
+    }
+    info(msg, context = "") {
+      if (_Logger.#levelIdx <= 4)
+        _Logger.#printMessages(this.name ?? "App", msg, context, "info");
+    }
+    warn(msg, context = "") {
+      if (_Logger.#levelIdx <= 5)
+        _Logger.#printMessages(this.name ?? "App", msg, context, "warn");
+    }
+    error(msg, context = "") {
+      if (_Logger.#levelIdx <= 6)
+        _Logger.#printMessages(this.name ?? "App", msg, context, "error");
+    }
+    raw(msg, method) {
+      _Logger.rawLog(msg, method);
+    }
+    rawLog(msg, method) {
+      _Logger.rawLog(msg, method);
+    }
+    static trace(msg, context = "") {
+      if (_Logger.#levelIdx <= 0)
+        _Logger.#printMessages("App", msg, context, "trace");
+    }
+    static verbose(msg, context = "") {
+      if (_Logger.#levelIdx <= 1)
+        _Logger.#printMessages("App", msg, context, "verbose");
+    }
+    static debug(msg, context = "") {
+      if (_Logger.#levelIdx <= 2)
+        _Logger.#printMessages("App", msg, context, "debug");
+    }
+    static log(msg, context = "") {
+      if (_Logger.#levelIdx <= 3)
+        _Logger.#printMessages("App", msg, context, "log");
+    }
+    static info(msg, context = "") {
+      if (_Logger.#levelIdx <= 4)
+        _Logger.#printMessages("App", msg, context, "info");
+    }
+    static warn(msg, context = "") {
+      if (_Logger.#levelIdx <= 5)
+        _Logger.#printMessages("App", msg, context, "warn");
+    }
+    static error(msg, context = "") {
+      if (_Logger.#levelIdx <= 6)
+        _Logger.#printMessages("App", msg, context, "error");
+    }
+    static #colorize(msg, logLevel) {
+      return colorizeMap[logLevel](msg);
+    }
+    static #printMessages(name, content, context, logLevel, writeStreamType = logLevel === "error" ? "stderr" : "stdout") {
+      if (this.#ignoreCtxSet.has(context))
+        return;
+      const now = (0, import_dayjs5.default)();
+      const processMsg = this.#colorize(
+        `[${name ?? "App"}] ${global.process?.pid ?? "window"} -`,
+        logLevel
+      );
+      const timestampMsg = now.format("MM/DD/YYYY, HH:mm:ss A");
+      const logLevelMsg = this.#colorize(logLevel.toUpperCase().padStart(7, " "), logLevel);
+      const contextMsg = context ? clc.yellow(`[${context}] `) : "";
+      const contentMsg = this.#colorize(content, logLevel);
+      const timeDiffMsg = clc.yellow(`+${now.diff(_Logger.#startAt, "ms")}ms`);
+      if (typeof window === "undefined")
+        process[writeStreamType].write(
+          `${processMsg} ${timestampMsg} ${logLevelMsg} ${contextMsg} ${contentMsg} ${timeDiffMsg}
+`
+        );
+      else
+        console.log(`${processMsg} ${timestampMsg} ${logLevelMsg} ${contextMsg} ${contentMsg} ${timeDiffMsg}
+`);
+    }
+    static rawLog(msg, method) {
+      this.raw(`${msg}
+`, method);
+    }
+    static raw(msg, method) {
+      if (typeof window === "undefined" && method !== "console" && global.process)
+        global.process.stdout.write(msg);
+      else
+        console.log(msg);
+    }
+  };
+
+  // pkgs/@akanjs/constant/src/scalar.ts
+  var import_reflect_metadata = __require("reflect-metadata");
+  var scalarExampleMap = /* @__PURE__ */ new Map([
+    [ID, "1234567890abcdef12345678"],
+    [Int, 0],
+    [Float, 0],
+    [String, "String"],
+    [Boolean, true],
+    [Date, (/* @__PURE__ */ new Date()).toISOString()],
+    [Upload, "FileUpload"],
+    [JSON, {}],
+    [Map, {}]
+  ]);
+  var getClassMeta = (modelRef) => {
+    const [target] = getNonArrayModel(modelRef);
+    const classMeta = Reflect.getMetadata("class", target.prototype);
+    if (!classMeta)
+      throw new Error(`No ClassMeta for this target ${target.name}`);
+    return classMeta;
+  };
+  var getFieldMetas = (modelRef) => {
+    const [target] = 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));
+  };
+  var getFieldMetaMapOnPrototype = (prototype) => {
+    const metadataMap = Reflect.getMetadata("fields", prototype) ?? /* @__PURE__ */ new Map();
+    return new Map(metadataMap);
+  };
+  var setFieldMetaMapOnPrototype = (prototype, metadataMap) => {
+    Reflect.defineMetadata("fields", new Map(metadataMap), prototype);
+  };
+
+  // pkgs/@akanjs/constant/src/fieldMeta.ts
+  var applyFieldMeta = (modelRef, arrDepth, option, optionArrDepth) => {
+    const isArray = arrDepth > 0;
+    const isClass = !isGqlScalar(modelRef);
+    const isMap = isGqlMap(modelRef);
+    const { refName, type } = isClass ? getClassMeta(modelRef) : { refName: "", type: "scalar" };
+    const name = isClass ? refName : scalarNameMap.get(modelRef) ?? "Unknown";
+    if (isMap && !option.of)
+      throw new Error("Map type must have 'of' option");
+    return (prototype, key) => {
+      const metadata = {
+        nullable: option.nullable ?? false,
+        ref: option.ref,
+        refPath: option.refPath,
+        refType: option.refType,
+        default: option.default ?? (isArray ? [] : null),
+        type: option.type,
+        fieldType: option.fieldType ?? "property",
+        immutable: option.immutable ?? false,
+        min: option.min,
+        max: option.max,
+        enum: option.enum,
+        select: option.select ?? true,
+        minlength: option.minlength,
+        maxlength: option.maxlength,
+        query: option.query,
+        accumulate: option.accumulate,
+        example: option.example,
+        validate: option.validate,
+        key,
+        name,
+        isClass,
+        isScalar: type === "scalar",
+        modelRef,
+        arrDepth,
+        isArray,
+        optArrDepth: optionArrDepth,
+        isMap,
+        of: option.of,
+        text: option.text
+      };
+      const metadataMap = getFieldMetaMapOnPrototype(prototype);
+      metadataMap.set(key, metadata);
+      setFieldMetaMapOnPrototype(prototype, metadataMap);
+    };
+  };
+  var makeField = (customOption) => (returns, fieldOption) => {
+    const [modelRef, arrDepth] = getNonArrayModel(returns());
+    if (!fieldOption)
+      return applyFieldMeta(modelRef, arrDepth, { ...customOption }, arrDepth);
+    const [opt, optArrDepth] = getNonArrayModel(fieldOption);
+    return applyFieldMeta(modelRef, arrDepth, { ...opt, ...customOption }, optArrDepth);
+  };
+  var Field = {
+    Prop: makeField({ fieldType: "property" }),
+    Hidden: makeField({ fieldType: "hidden", nullable: true }),
+    Secret: makeField({ fieldType: "hidden", select: false, nullable: true }),
+    Resolve: makeField({ fieldType: "resolve" })
+  };
+
+  // pkgs/@akanjs/constant/src/constantDecorator.ts
+  var import_reflect_metadata2 = __require("reflect-metadata");
+
+  // pkgs/@akanjs/constant/src/filterMeta.ts
+  var setFilterMeta = (filterRef, filterMeta) => {
+    const existingFilterMeta = Reflect.getMetadata("filter", filterRef.prototype);
+    if (existingFilterMeta)
+      Object.assign(filterMeta.sort, existingFilterMeta.sort);
+    Reflect.defineMetadata("filter", filterMeta, filterRef.prototype);
+  };
+  var getFilterKeyMetaMapOnPrototype = (prototype) => {
+    const metadataMap = Reflect.getMetadata("filterKey", prototype) ?? /* @__PURE__ */ new Map();
+    return new Map(metadataMap);
+  };
+  var setFilterKeyMetaMapOnPrototype = (prototype, metadataMap) => {
+    Reflect.defineMetadata("filterKey", new Map(metadataMap), prototype);
+  };
+  var applyFilterKeyMeta = (option) => {
+    return (prototype, key, descriptor) => {
+      const metadata = { key, ...option, descriptor };
+      const metadataMap = getFilterKeyMetaMapOnPrototype(prototype);
+      metadataMap.set(key, metadata);
+      setFilterKeyMetaMapOnPrototype(prototype, metadataMap);
+    };
+  };
+  var makeFilter = (customOption) => (fieldOption) => {
+    return applyFilterKeyMeta({ ...customOption, ...fieldOption });
+  };
+  var getFilterArgMetasOnPrototype = (prototype, key) => {
+    const filterArgMetas = Reflect.getMetadata("filterArg", prototype, key) ?? [];
+    return filterArgMetas;
+  };
+  var setFilterArgMetasOnPrototype = (prototype, key, filterArgMetas) => {
+    Reflect.defineMetadata("filterArg", filterArgMetas, prototype, key);
+  };
+  var applyFilterArgMeta = (name, returns, argOption) => {
+    return (prototype, key, idx) => {
+      const [modelRef, arrDepth] = getNonArrayModel(returns());
+      const [opt, optArrDepth] = getNonArrayModel(argOption ?? {});
+      const filterArgMeta = { name, ...opt, modelRef, arrDepth, isArray: arrDepth > 0, optArrDepth };
+      const filterArgMetas = getFilterArgMetasOnPrototype(prototype, key);
+      filterArgMetas[idx] = filterArgMeta;
+      setFilterArgMetasOnPrototype(prototype, key, filterArgMetas);
+    };
+  };
+  var Filter = {
+    Mongo: makeFilter({ type: "mongo" }),
+    // Meili: makeFilter({ fieldType: "hidden", nullable: true }),
+    Arg: applyFilterArgMeta
+  };
+
+  // pkgs/@akanjs/constant/src/baseGql.ts
+  var import_reflect_metadata3 = __require("reflect-metadata");
+  var defaultFieldMeta = {
+    fieldType: "property",
+    immutable: false,
+    select: true,
+    isClass: false,
+    isScalar: true,
+    nullable: false,
+    isArray: false,
+    arrDepth: 0,
+    optArrDepth: 0,
+    default: null,
+    isMap: false
+  };
+  var idFieldMeta = { ...defaultFieldMeta, key: "id", name: "ID", modelRef: ID };
+  var createdAtFieldMeta = { ...defaultFieldMeta, key: "createdAt", name: "Date", modelRef: Date };
+  var updatedAtFieldMeta = { ...defaultFieldMeta, key: "updatedAt", name: "Date", modelRef: Date };
+  var removedAtFieldMeta = {
+    ...defaultFieldMeta,
+    key: "removedAt",
+    name: "Date",
+    modelRef: Date,
+    nullable: true,
+    default: null
+  };
+
+  // pkgs/@akanjs/constant/src/classMeta.ts
+  var import_reflect_metadata4 = __require("reflect-metadata");
+  var InputModelStorage = class {
+  };
+  var LightModelStorage = class {
+  };
+  var FullModelStorage = class {
+  };
+  var ScalarModelStorage = class {
+  };
+  var FilterModelStorage = class {
+  };
+  var hasTextField = (modelRef) => {
+    const fieldMetas = getFieldMetas(modelRef);
+    return fieldMetas.some(
+      (fieldMeta) => !!fieldMeta.text || fieldMeta.isScalar && fieldMeta.isClass && fieldMeta.select && hasTextField(fieldMeta.modelRef)
+    );
+  };
+  var applyClassMeta = (type, modelType, storage) => {
+    return function(refName) {
+      return function(target) {
+        const modelRef = target;
+        const classMeta = { refName, type, modelType, modelRef, hasTextField: hasTextField(modelRef) };
+        Reflect.defineMetadata("class", classMeta, modelRef.prototype);
+        Reflect.defineMetadata(refName, modelRef, storage.prototype);
+      };
+    };
+  };
+  var applyFilterMeta = (storage) => {
+    return function(refName) {
+      return function(target) {
+        const modelRef = target;
+        setFilterMeta(modelRef, { refName, sort: {} });
+        Reflect.defineMetadata(refName, modelRef, storage.prototype);
+      };
+    };
+  };
+  var Model = {
+    Light: applyClassMeta("light", "data", LightModelStorage),
+    Object: applyClassMeta("full", "ephemeral", FullModelStorage),
+    Full: applyClassMeta("full", "data", FullModelStorage),
+    Input: applyClassMeta("input", "data", InputModelStorage),
+    Scalar: applyClassMeta("scalar", "data", ScalarModelStorage),
+    Summary: applyClassMeta("scalar", "summary", ScalarModelStorage),
+    Insight: applyClassMeta("scalar", "insight", ScalarModelStorage),
+    Filter: applyFilterMeta(FilterModelStorage)
+  };
+
+  // pkgs/@akanjs/test/src/sample.ts
+  var import_chance = __toESM(__require("chance"));
+  var chance = new import_chance.default();
+  var sample = Object.assign(chance, {
+    dayjs: (opt) => dayjs(chance.date({ ...opt, min: opt?.min?.toDate(), max: opt?.max?.toDate() })),
+    pick: randomPick,
+    picks: randomPicks
+  });
+
+  // pkgs/@akanjs/test/src/sampleOf.ts
+  var getFieldTypeExample = {
+    email: () => sample.email(),
+    password: () => sample.string({ length: 8 }),
+    url: () => sample.url()
+  };
+  var scalarSampleMap = /* @__PURE__ */ new Map([
+    [ID, () => sample.hash({ length: 24 })],
+    [Int, () => sample.integer({ min: -1e4, max: 1e4 })],
+    [Float, () => sample.floating({ min: -1e4, max: 1e4 })],
+    [String, () => sample.string({ length: 100 })],
+    [Boolean, () => sample.bool()],
+    [Date, () => sample.dayjs()],
+    [Upload, () => "FileUpload"],
+    [JSON, () => ({})]
+  ]);
+  var getScalarSample = (ref, fieldMeta) => {
+    if (fieldMeta.type) {
+      return getFieldTypeExample[fieldMeta.type]();
+    } else if (typeof fieldMeta.min === "number") {
+      return fieldMeta.min;
+    } else if (typeof fieldMeta.max === "number") {
+      return fieldMeta.max;
+    } else {
+      return scalarSampleMap.get(ref)?.() ?? null;
+    }
+  };
+  var makeSample = (fieldMeta) => {
+    if (fieldMeta.default)
+      return typeof fieldMeta.default === "function" ? fieldMeta.default() : fieldMeta.default;
+    else if (fieldMeta.enum)
+      return randomPick([...fieldMeta.enum.values]);
+    if (isGqlScalar(fieldMeta.modelRef))
+      return getScalarSample(fieldMeta.modelRef, fieldMeta);
+    return Object.fromEntries(
+      getFieldMetas(fieldMeta.modelRef).map(
+        (fieldMeta2) => [
+          fieldMeta2.key,
+          fieldMeta2.arrDepth ? [] : fieldMeta2.isClass && !fieldMeta2.isScalar ? null : makeSample(fieldMeta2)
+        ]
+      )
+    );
+  };
+  var sampleOf = (modelRef) => {
+    return Object.fromEntries(
+      getFieldMetas(modelRef).map((fieldMeta) => [
+        fieldMeta.key,
+        fieldMeta.arrDepth ? [] : fieldMeta.isClass && !fieldMeta.isScalar ? null : makeSample(fieldMeta)
+      ])
+    );
+  };
+})();
+//! Nextjs는 환경변수를 build time에 그냥 하드코딩으로 값을 넣어버림. operationMode같은것들 잘 동작안할 수 있음. 추후 수정 필요.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/test",
-  "version": "0.0.40",
+  "version": "0.0.41",
   "type": "commonjs",
   "publishConfig": {
     "access": "public"
@@ -14,5 +14,10 @@
   "engines": {
     "node": ">=22"
   },
-  "dependencies": {}
+  "dependencies": {
+    "chance": "^1.1.12",
+    "dayjs": "^1.11.13",
+    "pluralize": "^8.0.0",
+    "reflect-metadata": "^0.2.2"
+  }
 }

package/src/index.d.ts

@@ -1,3 +1,2 @@
-export { sampleOf } from './sampleOf.js';
-export { sample } from './sample.js';
-import 'dayjs';
+export { sampleOf } from "./sampleOf";
+export { sample } from "./sample";