functional-models 3.10.0 → 3.11.0

package/cjs/orm/properties.cjs

@@ -0,0 +1,989 @@
+"use strict";
+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 __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 __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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/orm/properties.ts
+var properties_exports = {};
+__export(properties_exports, {
+  ForeignKeyProperty: () => ForeignKeyProperty,
+  LastModifiedDateProperty: () => LastModifiedDateProperty,
+  PrimaryKeyProperty: () => PrimaryKeyProperty,
+  ormPropertyConfig: () => ormPropertyConfig
+});
+module.exports = __toCommonJS(properties_exports);
+var import_merge5 = __toESM(require("lodash/merge.js"), 1);
+var import_identity = __toESM(require("lodash/identity.js"), 1);
+
+// src/properties.ts
+var import_merge3 = __toESM(require("lodash/merge.js"), 1);
+var import_get3 = __toESM(require("lodash/get.js"), 1);
+
+// node_modules/uuid/dist-node/stringify.js
+var byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+}
+
+// node_modules/uuid/dist-node/rng.js
+var rnds8 = new Uint8Array(16);
+function rng() {
+  return crypto.getRandomValues(rnds8);
+}
+
+// node_modules/uuid/dist-node/v4.js
+function v4(options, buf, offset) {
+  if (!buf && !options && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return _v4(options, buf, offset);
+}
+function _v4(options, buf, offset) {
+  options = options || {};
+  const rnds = options.random ?? options.rng?.() ?? rng();
+  if (rnds.length < 16) {
+    throw new Error("Random bytes length must be >= 16");
+  }
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    if (offset < 0 || offset + 16 > buf.length) {
+      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+    }
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
+}
+var v4_default = v4;
+
+// src/validation.ts
+var import_isEmpty = __toESM(require("lodash/isEmpty.js"), 1);
+var import_merge = __toESM(require("lodash/merge.js"), 1);
+var import_flatMap = __toESM(require("lodash/flatMap.js"), 1);
+var import_get = __toESM(require("lodash/get.js"), 1);
+
+// src/utils.ts
+var import_async_lock = __toESM(require("async-lock"), 1);
+var import_get_random_values = __toESM(require("get-random-values"), 1);
+var getRandomValues = () => {
+  const array = new Uint8Array(1);
+  if (typeof window !== "undefined") {
+    if (window.crypto) {
+      return window.crypto.getRandomValues(array);
+    }
+    if (window.msCrypto) {
+      return window.msCrypto.getRandomValues(array);
+    }
+  }
+  return (0, import_get_random_values.default)(array);
+};
+var PluralEndings = /* @__PURE__ */ ((PluralEndings2) => {
+  PluralEndings2["ves"] = "fe";
+  PluralEndings2["ies"] = "y";
+  PluralEndings2["i"] = "us";
+  PluralEndings2["zes"] = "ze";
+  PluralEndings2["ses"] = "s";
+  PluralEndings2["es"] = "e";
+  PluralEndings2["s"] = "";
+  return PluralEndings2;
+})(PluralEndings || {});
+var _singularizingRe = new RegExp(
+  `(${Object.keys(PluralEndings).join("|")})$`,
+  "u"
+);
+var flowFindFirst = (funcs) => (input) => {
+  return funcs.reduce((acc, func) => {
+    if (acc) {
+      return acc;
+    }
+    return func(input);
+  }, void 0);
+};
+var memoizeSync = (method) => {
+  let value = void 0;
+  let called = false;
+  return (...args) => {
+    if (!called) {
+      called = true;
+      value = method(...args);
+    }
+    return value;
+  };
+};
+var memoizeAsync = (method) => {
+  const key = v4_default();
+  const lock = new import_async_lock.default();
+  let value = void 0;
+  let called = false;
+  return async (...args) => {
+    return lock.acquire(key, async () => {
+      if (!called) {
+        called = true;
+        value = await method(...args);
+      }
+      return value;
+    });
+  };
+};
+var createUuid = v4_default;
+
+// src/validation.ts
+var multiValidator = (validators) => {
+  const flow3 = flowFindFirst(
+    validators
+  );
+  return flow3;
+};
+var filterEmpty = (array) => {
+  return array.filter((x) => x);
+};
+var _trueOrError = (method, error) => (value) => {
+  if (method(value) === false) {
+    return error;
+  }
+  return void 0;
+};
+var _typeOrError = (type, errorMessage) => (value) => {
+  if (typeof value !== type) {
+    return errorMessage;
+  }
+  return void 0;
+};
+var isType = (type) => (value) => {
+  return _typeOrError(type, `Must be a ${type}`)(value);
+};
+var isNumber = isType("number");
+var isInteger = _trueOrError(Number.isInteger, "Must be an integer");
+var isObject = multiValidator([
+  isType("object"),
+  (x) => Array.isArray(x) ? "Must be an object, but got an array" : void 0
+]);
+var isBoolean = isType("boolean");
+var isString = isType("string");
+var isArray = _trueOrError(
+  (v) => Array.isArray(v),
+  "Value is not an array"
+);
+var PRIMITIVE_TO_SPECIAL_TYPE_VALIDATOR = {
+  ["boolean" /* boolean */]: isBoolean,
+  ["string" /* string */]: isString,
+  ["integer" /* integer */]: isInteger,
+  ["number" /* number */]: isNumber,
+  ["object" /* object */]: isObject
+};
+var meetsRegex = (regex, flags, errorMessage = "Format was invalid") => (value) => {
+  const reg = new RegExp(regex, flags);
+  return _trueOrError((v) => reg.test(v), errorMessage)(value);
+};
+var choices = (choiceArray) => (value) => {
+  if (Array.isArray(value)) {
+    const bad = value.find((v) => !choiceArray.includes(v));
+    if (bad) {
+      return `${bad} is not a valid choice`;
+    }
+  } else {
+    if (!choiceArray.includes(value)) {
+      return `${value} is not a valid choice`;
+    }
+  }
+  return void 0;
+};
+var isDate = (value) => {
+  if (!value) {
+    return "Date value is empty";
+  }
+  if (!value.toISOString) {
+    return "Value is not a date";
+  }
+  return void 0;
+};
+var isRequired = (value) => {
+  if (value === true || value === false) {
+    return void 0;
+  }
+  if (isNumber(value) === void 0) {
+    return void 0;
+  }
+  const empty = (0, import_isEmpty.default)(value);
+  if (empty) {
+    if (isDate(value)) {
+      return "A value is required";
+    }
+  }
+  return void 0;
+};
+var maxNumber = (max) => (value) => {
+  const numberError = isNumber(value);
+  if (numberError) {
+    return numberError;
+  }
+  if (value && value > max) {
+    return `The maximum is ${max}`;
+  }
+  return void 0;
+};
+var minNumber = (min) => (value) => {
+  const numberError = isNumber(value);
+  if (numberError) {
+    return numberError;
+  }
+  if (value && value < min) {
+    return `The minimum is ${min}`;
+  }
+  return void 0;
+};
+var maxTextLength = (max) => (value) => {
+  const stringError = isString(value);
+  if (stringError) {
+    return stringError;
+  }
+  if (value && value.length > max) {
+    return `The maximum length is ${max}`;
+  }
+  return void 0;
+};
+var minTextLength = (min) => (value) => {
+  const stringError = isString(value);
+  if (stringError) {
+    return stringError;
+  }
+  if (value && value.length < min) {
+    return `The minimum length is ${min}`;
+  }
+  return void 0;
+};
+var aggregateValidator = (value, methodOrMethods) => {
+  const toDo = Array.isArray(methodOrMethods) ? methodOrMethods : [methodOrMethods];
+  const _aggregativeValidator = async (model, instanceData, propertyConfiguration) => {
+    const values = await Promise.all(
+      toDo.map((method) => {
+        return method(value, model, instanceData, propertyConfiguration);
+      })
+    );
+    return filterEmpty(values);
+  };
+  return _aggregativeValidator;
+};
+var emptyValidator = () => void 0;
+var _boolChoice = (method) => (configValue) => {
+  const func = method(configValue);
+  const validatorWrapper = func;
+  return validatorWrapper;
+};
+var simpleFuncWrap = (validator) => () => {
+  return validator;
+};
+var includeOrDont = (method) => (configValue) => {
+  if (configValue === false) {
+    return emptyValidator;
+  }
+  const func = method();
+  const validatorWrapper = func;
+  return validatorWrapper;
+};
+var CONFIG_TO_VALIDATE_METHOD = () => ({
+  required: includeOrDont(simpleFuncWrap(isRequired)),
+  isInteger: _boolChoice(simpleFuncWrap(isInteger)),
+  isNumber: _boolChoice(simpleFuncWrap(isNumber)),
+  isString: _boolChoice(simpleFuncWrap(isString)),
+  isArray: _boolChoice(simpleFuncWrap(isArray)),
+  isBoolean: _boolChoice(simpleFuncWrap(isBoolean)),
+  choices: _boolChoice(choices)
+});
+var createPropertyValidator = (valueGetter, config) => {
+  const _propertyValidator = async (model, instanceData, propertyConfiguration) => {
+    return Promise.resolve().then(async () => {
+      const configToValidateMethod = CONFIG_TO_VALIDATE_METHOD();
+      if (!config) {
+        config = {};
+      }
+      const validators = [
+        ...Object.entries(config).map(([key, value2]) => {
+          const method = configToValidateMethod[key];
+          if (method) {
+            return method(value2);
+          }
+          return emptyValidator;
+        }),
+        ...config.validators ? config.validators : []
+      ].filter((x) => x);
+      const value = await valueGetter();
+      const isRequiredValue = config.required ? true : validators.includes(isRequired);
+      if (!value && !isRequiredValue) {
+        return [];
+      }
+      const validator = aggregateValidator(value, validators);
+      const errors = await validator(model, instanceData, propertyConfiguration);
+      return [...new Set((0, import_flatMap.default)(errors))];
+    });
+  };
+  return _propertyValidator;
+};
+var optionalValidator = (validator) => {
+  return (v) => {
+    if (v === void 0 || v === null) {
+      return void 0;
+    }
+    return validator(v);
+  };
+};
+var UUID_VALIDATOR = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-5][0-9a-f]{3}-[089ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
+var isValidUuid = (uuid) => {
+  const stringError = isString(uuid);
+  if (stringError) {
+    return stringError;
+  }
+  return meetsRegex(UUID_VALIDATOR, "g", "Invalid UUID format")(uuid);
+};
+
+// src/lib.ts
+var import_openapi_types = require("openapi-types");
+var import_kebabCase = __toESM(require("lodash/kebabCase.js"), 1);
+var import_flow = __toESM(require("lodash/flow.js"), 1);
+var import_merge2 = __toESM(require("lodash/merge.js"), 1);
+var import_get2 = __toESM(require("lodash/get.js"), 1);
+var import_zod = require("zod");
+var HttpMethods = import_openapi_types.OpenAPIV3.HttpMethods;
+var NULL_METHOD = HttpMethods.HEAD;
+var ID_KEY = ":id";
+var getCommonTextValidators = (config) => {
+  return [
+    getValidatorFromConfigElseEmpty(config?.maxLength, maxTextLength),
+    getValidatorFromConfigElseEmpty(config?.minLength, minTextLength)
+  ];
+};
+var getValidatorFromConfigElseEmpty = (input, validatorGetter) => {
+  if (input !== void 0) {
+    const validator = validatorGetter(input);
+    return validator;
+  }
+  return emptyValidator;
+};
+var getCommonNumberValidators = (config) => {
+  return [
+    getValidatorFromConfigElseEmpty(config?.minValue, minNumber),
+    getValidatorFromConfigElseEmpty(config?.maxValue, maxNumber)
+  ];
+};
+var mergeValidators = (config, ...validators) => {
+  return [...validators, ...config?.validators ? config.validators : []];
+};
+var buildValidEndpoint = (...components) => {
+  const suffix = components.map((x) => {
+    if (x === ID_KEY) {
+      return x;
+    }
+    return (0, import_kebabCase.default)(x);
+  }).map((s) => s.toLowerCase()).join("/");
+  return `/${suffix}`;
+};
+var _generateRestInfo = (method, withId, ...additional) => (pluralName, namespace) => (existing) => {
+  if (existing) {
+    return {
+      // Default add security, then override it.
+      security: {},
+      ...existing
+    };
+  }
+  const endpoint = withId ? buildValidEndpoint(namespace, pluralName, ID_KEY) : buildValidEndpoint(namespace, pluralName, ...additional);
+  return {
+    method,
+    endpoint,
+    // We cannot auto create security.
+    security: {}
+  };
+};
+var _apiMethodToRestInfoGenerator = {
+  ["create" /* create */]: _generateRestInfo(HttpMethods.POST, false),
+  ["retrieve" /* retrieve */]: _generateRestInfo(HttpMethods.GET, true),
+  ["update" /* update */]: _generateRestInfo(HttpMethods.PUT, true),
+  ["delete" /* delete */]: _generateRestInfo(HttpMethods.DELETE, true),
+  ["search" /* search */]: _generateRestInfo(HttpMethods.POST, false, "search")
+};
+var createZodForProperty = (propertyType, config) => () => {
+  const myConfig = config || {};
+  const provided = myConfig.zod;
+  if (provided) {
+    return provided;
+  }
+  const _getZodForPropertyType = (pt) => {
+    if (myConfig.choices) {
+      return import_zod.z.enum(myConfig.choices);
+    }
+    switch (pt) {
+      case "UniqueId":
+        return import_zod.z.string();
+      case "Date":
+      case "Datetime":
+        return import_zod.z.union([import_zod.z.string(), import_zod.z.date()]);
+      case "Integer":
+        return import_zod.z.number().int();
+      case "Number":
+        return import_zod.z.number();
+      case "Boolean":
+        return import_zod.z.boolean();
+      case "Array":
+        return import_zod.z.array(import_zod.z.any());
+      case "Object":
+        return import_zod.z.object().loose();
+      case "Email":
+        return import_zod.z.email();
+      case "Text":
+      case "BigText":
+        return import_zod.z.string();
+      case "ModelReference":
+        return import_zod.z.union([import_zod.z.string(), import_zod.z.number()]);
+      default:
+        return import_zod.z.any();
+    }
+  };
+  const baseSchema = _getZodForPropertyType(propertyType);
+  const choices2 = config?.choices;
+  const schemaFromChoices = choices2 && Array.isArray(choices2) && choices2.length > 0 ? import_zod.z.union(choices2.map((c) => import_zod.z.literal(c))) : baseSchema;
+  const finalSchema = (0, import_flow.default)([
+    (s) => typeof myConfig.minValue === "number" ? s.min(myConfig.minValue) : s,
+    (s) => typeof myConfig.maxValue === "number" ? s.max(myConfig.maxValue) : s,
+    (s) => typeof myConfig.minLength === "number" ? s.min(myConfig.minLength) : s,
+    (s) => typeof myConfig.maxLength === "number" ? s.max(myConfig.maxLength) : s,
+    (s) => myConfig.defaultValue !== void 0 ? s.default(myConfig.defaultValue) : s,
+    (s) => myConfig.required ? s : s.optional(),
+    // Attach description for Zod consumers and OpenAPI generators.
+    (s) => {
+      if (myConfig.description) {
+        if (typeof s.openapi === "function") {
+          return s.openapi({ description: myConfig.description });
+        }
+        return s.meta ? s.meta({ description: myConfig.description }) : s.describe(myConfig.description);
+      }
+      return s;
+    }
+  ])(schemaFromChoices);
+  return finalSchema;
+};
+
+// src/properties.ts
+var Property = (propertyType, config = {}, additionalMetadata = {}) => {
+  if (!propertyType && !config?.typeOverride) {
+    throw new Error(`Property type must be provided.`);
+  }
+  if (config?.typeOverride) {
+    propertyType = config.typeOverride;
+  }
+  const getConstantValue = () => config?.value !== void 0 ? config.value : void 0;
+  const getDefaultValue = () => config?.defaultValue !== void 0 ? config.defaultValue : void 0;
+  const getChoices = () => config?.choices || [];
+  const lazyLoadMethod = config?.lazyLoadMethod || false;
+  const valueSelector = config?.valueSelector || ((x) => x);
+  if (typeof valueSelector !== "function") {
+    throw new Error(`valueSelector must be a function`);
+  }
+  const createGetter = (instanceValue, modelData, instance) => {
+    const constantValue = getConstantValue();
+    if (constantValue !== void 0) {
+      return () => constantValue;
+    }
+    const defaultValue = getDefaultValue();
+    if (defaultValue !== void 0 && (instanceValue === null || instanceValue === void 0)) {
+      return () => defaultValue;
+    }
+    const method = lazyLoadMethod ? lazyLoadMethod : config.lazyLoadMethodAtomic ? memoizeAsync(config.lazyLoadMethodAtomic) : typeof instanceValue === "function" ? instanceValue : () => instanceValue;
+    const valueGetter = memoizeSync(() => {
+      const result = method(
+        instanceValue,
+        modelData,
+        // @ts-ignore
+        instance
+      );
+      return valueSelector(result);
+    });
+    return valueGetter;
+  };
+  const getValidator = (valueGetter) => {
+    const validator = createPropertyValidator(valueGetter, config);
+    const _propertyValidatorWrapper = async (model, instanceData, propertyConfiguration) => {
+      return validator(model, instanceData, propertyConfiguration);
+    };
+    return _propertyValidatorWrapper;
+  };
+  const getZod = () => {
+    const provided = config?.zod;
+    if (provided) {
+      return provided;
+    }
+    return createZodForProperty(propertyType, config)();
+  };
+  const propertyInstance = {
+    ...additionalMetadata,
+    getConfig: () => config || {},
+    getChoices,
+    getDefaultValue,
+    getConstantValue,
+    getPropertyType: () => propertyType,
+    createGetter,
+    getZod,
+    getValidator
+  };
+  return propertyInstance;
+};
+var isDate2 = (value) => {
+  if (value === null) {
+    return false;
+  }
+  return typeof value === "object" && value.toISOString;
+};
+var DatetimeProperty = (config = {}, additionalMetadata = {}) => Property(
+  "Datetime" /* Datetime */,
+  (0, import_merge3.default)(
+    {
+      lazyLoadMethod: (value) => {
+        if (isDate2(value)) {
+          if (config.formatFunction) {
+            return config.formatFunction(value, config.format);
+          }
+          return value.toISOString();
+        }
+        if (!value && config?.autoNow) {
+          const date = /* @__PURE__ */ new Date();
+          if (config.formatFunction) {
+            return config.formatFunction(date, config.format);
+          }
+          return date.toISOString();
+        }
+        return value;
+      }
+    },
+    config
+  ),
+  additionalMetadata
+);
+var TextProperty = (config = {}, additionalMetadata = {}) => Property(
+  "Text" /* Text */,
+  (0, import_merge3.default)(config, {
+    isString: true,
+    // @ts-ignore
+    validators: mergeValidators(config, ...getCommonTextValidators(config))
+  }),
+  additionalMetadata
+);
+var IntegerProperty = (config = {}, additionalMetadata = {}) => Property(
+  "Integer" /* Integer */,
+  (0, import_merge3.default)(config, {
+    isInteger: true,
+    validators: mergeValidators(
+      config,
+      ...getCommonNumberValidators(config)
+    )
+  }),
+  additionalMetadata
+);
+var UuidProperty = (config = {}, additionalMetadata = {}) => Property(
+  "UniqueId" /* UniqueId */,
+  (0, import_merge3.default)(config, {
+    isString: true,
+    validators: mergeValidators(
+      config,
+      config.required ? isValidUuid : optionalValidator(isValidUuid)
+    ),
+    lazyLoadMethod: (value) => {
+      if (!value) {
+        if (config.autoNow) {
+          return v4_default();
+        }
+      }
+      return value;
+    }
+  }),
+  additionalMetadata
+);
+
+// src/orm/validation.ts
+var import_flow2 = __toESM(require("lodash/flow.js"), 1);
+
+// src/orm/query.ts
+var import_merge4 = __toESM(require("lodash/merge.js"), 1);
+var import_omit = __toESM(require("lodash/omit.js"), 1);
+
+// src/orm/types.ts
+var EqualitySymbol = /* @__PURE__ */ ((EqualitySymbol2) => {
+  EqualitySymbol2["eq"] = "=";
+  EqualitySymbol2["lt"] = "<";
+  EqualitySymbol2["lte"] = "<=";
+  EqualitySymbol2["gt"] = ">";
+  EqualitySymbol2["gte"] = ">=";
+  EqualitySymbol2["ne"] = "!=";
+  return EqualitySymbol2;
+})(EqualitySymbol || {});
+var AllowableEqualitySymbols = Object.values(EqualitySymbol);
+
+// src/orm/query.ts
+var _objectize = (key, value) => {
+  return value ? {
+    [key]: value
+  } : {};
+};
+var _additionalLink = (data) => {
+  const inner = _builderV2(data);
+  const partialLink = (0, import_omit.default)(_link(data), ["and", "or"]);
+  return {
+    ...inner,
+    ...partialLink
+  };
+};
+var _link = (data) => {
+  return {
+    and: () => {
+      return _queryBuilder({ ...data, query: data.query.concat("AND") });
+    },
+    or: () => {
+      return _queryBuilder({ ...data, query: data.query.concat("OR") });
+    },
+    compile: () => {
+      return data;
+    },
+    take: (num) => {
+      return _additionalLink({ ...data, take: take(num) });
+    },
+    sort: (key, order = "asc" /* asc */) => {
+      return _additionalLink({ ...data, sort: sort(key, order) });
+    },
+    pagination: (value) => {
+      return _additionalLink({ ...data, page: pagination(value) });
+    }
+  };
+};
+var _canCompile = (obj) => {
+  return Boolean(obj.compile);
+};
+var _builderV2 = (data) => {
+  const _myProperty = (name, value, options) => {
+    const p = property(name, value, options);
+    return _link((0, import_merge4.default)(data, { query: data.query.concat(p) }));
+  };
+  const complex = (subBuilderFunc) => {
+    const subBuilder = _queryBuilder();
+    const result = subBuilderFunc(subBuilder);
+    if (_canCompile(result)) {
+      const queryTokens = [result.compile().query];
+      return _link(
+        (0, import_merge4.default)(data, {
+          query: data.query.concat(queryTokens)
+        })
+      );
+    }
+    return _link((0, import_merge4.default)(data, { query: data.query.concat([result.query]) }));
+  };
+  const thisDatesBefore = (key, jsDate, { valueType = "date" /* date */, equalToAndBefore = true } = {}) => {
+    const p = datesBefore(key, jsDate, { valueType, equalToAndBefore });
+    return _link((0, import_merge4.default)(data, { query: data.query.concat(p) }));
+  };
+  const thisDatesAfter = (key, jsDate, { valueType = "date" /* date */, equalToAndAfter = true } = {}) => {
+    const p = datesAfter(key, jsDate, { valueType, equalToAndAfter });
+    return _link((0, import_merge4.default)(data, { query: data.query.concat(p) }));
+  };
+  return {
+    datesBefore: thisDatesBefore,
+    datesAfter: thisDatesAfter,
+    complex,
+    property: _myProperty
+  };
+};
+var _queryBuilder = (data = void 0) => {
+  const theData = (0, import_merge4.default)(
+    {
+      query: []
+    },
+    data
+  );
+  const builder = _builderV2(theData);
+  const linkData = _additionalLink(theData);
+  return {
+    ...builder,
+    ...linkData,
+    compile: () => {
+      return {
+        ..._objectize("take", theData.take),
+        ..._objectize("sort", theData.sort),
+        ..._objectize("page", theData.page),
+        query: []
+      };
+    }
+  };
+};
+var property = (key, value, options = {}) => {
+  const {
+    equalitySymbol = "=" /* eq */,
+    caseSensitive,
+    startsWith,
+    endsWith,
+    includes,
+    type
+  } = options;
+  const typeToUse = type || "string" /* string */;
+  if (!AllowableEqualitySymbols.includes(equalitySymbol)) {
+    throw new Error(`${equalitySymbol} is not a valid symbol`);
+  }
+  if (equalitySymbol !== "=" /* eq */ && equalitySymbol !== "!=" /* ne */ && typeToUse === "string" /* string */) {
+    throw new Error(`Cannot use a non = symbol for a string type`);
+  }
+  const propertyEntry = {
+    type: "property",
+    key,
+    value,
+    valueType: typeToUse,
+    equalitySymbol,
+    options: {
+      ..._objectize("caseSensitive", caseSensitive),
+      ..._objectize("startsWith", startsWith),
+      ..._objectize("endsWith", endsWith),
+      ..._objectize("includes", includes)
+    }
+  };
+  return propertyEntry;
+};
+var take = (max) => {
+  const parsed = parseInt(`${max}`, 10);
+  if (Number.isNaN(parsed)) {
+    throw new Error(`Number "${max}" is not integerable`);
+  }
+  return parsed;
+};
+var sort = (key, order = "asc" /* asc */) => {
+  if (order !== "asc" /* asc */ && order !== "dsc" /* dsc */) {
+    throw new Error("Sort must be either asc or dsc");
+  }
+  return {
+    key,
+    order
+  };
+};
+var pagination = (value) => {
+  return value;
+};
+var datesAfter = (key, jsDate, options = {
+  valueType: "date" /* date */,
+  equalToAndAfter: true
+}) => {
+  const { valueType = "date" /* date */, equalToAndAfter = true } = options;
+  return {
+    type: "datesAfter",
+    key,
+    date: isDate3(jsDate) ? jsDate.toISOString() : jsDate,
+    valueType,
+    options: {
+      equalToAndAfter
+    }
+  };
+};
+var isDate3 = (obj) => {
+  return Boolean(obj.toISOString);
+};
+var datesBefore = (key, jsDate, options = {
+  valueType: "date" /* date */,
+  equalToAndBefore: true
+}) => {
+  const { valueType = "date" /* date */, equalToAndBefore = true } = options;
+  return {
+    type: "datesBefore",
+    key,
+    date: isDate3(jsDate) ? jsDate.toISOString() : jsDate,
+    valueType,
+    options: {
+      equalToAndBefore
+    }
+  };
+};
+var queryBuilder = () => {
+  return _queryBuilder();
+};
+
+// src/orm/validation.ts
+var _doUniqueCheck = async (query, model, instanceData, buildErrorMessage) => {
+  const results = await model.search(query);
+  const resultsLength = results.instances.length;
+  if (resultsLength < 1) {
+    return void 0;
+  }
+  const ids = await Promise.all(
+    results.instances.map((x) => x.getPrimaryKey())
+  );
+  const instanceId = instanceData[model.getModelDefinition().primaryKeyName];
+  if (ids.length === 1 && ids[0] === instanceId) {
+    return void 0;
+  }
+  if (ids.length > 1) {
+    if (ids.find((x) => x === instanceId)) {
+      return void 0;
+    }
+  }
+  return buildErrorMessage();
+};
+var uniqueTogether = (propertyKeyArray) => {
+  const _uniqueTogether = async (model, instanceData, options) => {
+    if (options?.noOrmValidation) {
+      return void 0;
+    }
+    const properties = propertyKeyArray.map((key) => {
+      return [key, instanceData[key]];
+    });
+    const query = (0, import_flow2.default)(
+      properties.map(([key, value], index) => {
+        return (b) => {
+          if (index + 1 >= properties.length) {
+            return b.property(key, value, { caseSensitive: false });
+          }
+          return b.property(key, value, { caseSensitive: false }).and();
+        };
+      })
+    )(queryBuilder().take(2)).compile();
+    return _doUniqueCheck(query, model, instanceData, () => {
+      return propertyKeyArray.length > 1 ? `${propertyKeyArray.join(
+        ","
+      )} must be unique together. Another instance found.` : `${propertyKeyArray[0]} must be unique. Another instance found.`;
+    });
+  };
+  return _uniqueTogether;
+};
+var unique = (propertyKey) => {
+  const _unique = (value, model, instanceData, options) => {
+    return uniqueTogether([propertyKey])(model, instanceData, options);
+  };
+  return _unique;
+};
+
+// src/orm/internal-libs.ts
+var _getModelIdPropertyType = (config = {}) => {
+  return config.dataType || "UniqueId" /* UniqueId */;
+};
+var getPrimaryKeyGenerator = (config = {}) => {
+  const custom = config.primaryKeyGenerator;
+  if (custom) {
+    return custom;
+  }
+  const idType = _getModelIdPropertyType(config);
+  switch (idType) {
+    case "Integer" /* Integer */:
+      return () => Promise.resolve(getRandomValues()[0]);
+    default: {
+      return () => Promise.resolve(createUuid());
+    }
+  }
+};
+
+// src/orm/properties.ts
+var _defaultPropertyConfig = {
+  unique: void 0
+};
+var LastModifiedDateProperty = (config = {}) => {
+  const additionalMetadata = { lastModifiedUpdateMethod: () => /* @__PURE__ */ new Date() };
+  return DatetimeProperty(config, additionalMetadata);
+};
+var ForeignKeyProperty = (model, config = {}) => {
+  const _getModel = () => {
+    if (typeof model === "function") {
+      return model();
+    }
+    return model;
+  };
+  const _getProperty = () => {
+    if (config.dataType === "UniqueId" /* UniqueId */) {
+      return UuidProperty(
+        (0, import_merge5.default)(config, {
+          autoNow: false
+        })
+      );
+    }
+    if (config.dataType === "Integer" /* Integer */) {
+      return IntegerProperty(config);
+    }
+    return TextProperty(config);
+  };
+  const property2 = _getProperty();
+  return (0, import_merge5.default)(property2, {
+    getReferencedId: (instanceValues) => {
+      return instanceValues;
+    },
+    getReferencedModel: _getModel
+  });
+};
+var PrimaryKeyProperty = (config = {}) => {
+  const _getProperty = () => {
+    const auto = config.auto === void 0 ? true : config.auto ? true : false;
+    const lazyLoadMethod = (value, modelData, instance) => {
+      if (config.primaryKeyGenerator) {
+        return config.primaryKeyGenerator(value, modelData, instance);
+      }
+      if (auto) {
+        return getPrimaryKeyGenerator(config)(value, modelData, instance);
+      }
+      return value;
+    };
+    if (config.dataType === "UniqueId" /* UniqueId */) {
+      return UuidProperty(
+        (0, import_merge5.default)(config, {
+          autoNow: auto,
+          lazyLoadMethod
+        })
+      );
+    }
+    if (config.dataType === "Integer" /* Integer */) {
+      return IntegerProperty(
+        (0, import_merge5.default)(config, {
+          lazyLoadMethod
+        })
+      );
+    }
+    return TextProperty(
+      (0, import_merge5.default)(config, {
+        lazyLoadMethod
+      })
+    );
+  };
+  return _getProperty();
+};
+var ormPropertyConfig = (config = _defaultPropertyConfig) => {
+  return (0, import_merge5.default)(config, {
+    validators: [
+      ...config.validators ? config.validators : [],
+      config.unique ? unique(config.unique) : null
+    ].filter(import_identity.default)
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ForeignKeyProperty,
+  LastModifiedDateProperty,
+  PrimaryKeyProperty,
+  ormPropertyConfig
+});
+//# sourceMappingURL=properties.cjs.map