functional-models 3.10.0 → 3.11.0

package/cjs/properties.cjs

@@ -0,0 +1,998 @@
+"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/properties.ts
+var properties_exports = {};
+__export(properties_exports, {
+  AdvancedModelReferenceProperty: () => AdvancedModelReferenceProperty,
+  ArrayProperty: () => ArrayProperty,
+  BigTextProperty: () => BigTextProperty,
+  BooleanProperty: () => BooleanProperty,
+  ConstantValueProperty: () => ConstantValueProperty,
+  DateProperty: () => DateProperty,
+  DatetimeProperty: () => DatetimeProperty,
+  DenormalizedIntegerProperty: () => DenormalizedIntegerProperty,
+  DenormalizedNumberProperty: () => DenormalizedNumberProperty,
+  DenormalizedProperty: () => DenormalizedProperty,
+  DenormalizedTextProperty: () => DenormalizedTextProperty,
+  EmailProperty: () => EmailProperty,
+  IntegerProperty: () => IntegerProperty,
+  ModelReferenceProperty: () => ModelReferenceProperty,
+  NaturalIdProperty: () => NaturalIdProperty,
+  NumberProperty: () => NumberProperty,
+  ObjectProperty: () => ObjectProperty,
+  PrimaryKeyUuidProperty: () => PrimaryKeyUuidProperty,
+  Property: () => Property,
+  SingleTypeArrayProperty: () => SingleTypeArrayProperty,
+  TextProperty: () => TextProperty,
+  UuidProperty: () => UuidProperty,
+  YearProperty: () => YearProperty
+});
+module.exports = __toCommonJS(properties_exports);
+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 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 createHeadAndTail = (values, joiner) => {
+  const head = values[0];
+  const tail = values.slice(1).join(joiner);
+  return [head, tail];
+};
+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;
+    });
+  };
+};
+
+// src/validation.ts
+var multiValidator = (validators) => {
+  const flow2 = flowFindFirst(
+    validators
+  );
+  return flow2;
+};
+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 arrayType = (type) => (value) => {
+  const arrayError = isArray(value);
+  if (arrayError) {
+    return arrayError;
+  }
+  const validator = PRIMITIVE_TO_SPECIAL_TYPE_VALIDATOR[type] || isType(type);
+  return value.reduce(
+    (acc, v) => {
+      if (acc) {
+        return acc;
+      }
+      return validator(v);
+    },
+    void 0
+  );
+};
+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 referenceTypeMatch = (referencedModel) => {
+  return (value) => {
+    const theType = typeof value;
+    switch (theType) {
+      case "string":
+      case "number":
+      case "undefined":
+        return void 0;
+      default:
+        break;
+    }
+    if (value === null) {
+      return void 0;
+    }
+    const model = typeof referencedModel === "function" ? referencedModel() : referencedModel;
+    const eModel = model.getName();
+    const aModel = value.getModel().getName();
+    if (eModel !== aModel) {
+      return `Model should be ${eModel} instead, received ${aModel}`;
+    }
+    return void 0;
+  };
+};
+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 getValueForReferencedModel = async (modelInstance, path) => {
+  const [head, tail] = createHeadAndTail(path.split("."), ".");
+  if (!tail) {
+    return modelInstance.getReferences()[head]();
+  }
+  const modelReference = await modelInstance.get[head]();
+  if (modelReference.toObj) {
+    const [nestedHead, nestedTail] = createHeadAndTail(tail.split("."), ".");
+    const value = await modelReference.get[nestedHead]();
+    if (nestedTail) {
+      return (0, import_get2.default)(value, nestedTail);
+    }
+    return value;
+  }
+  return (0, import_get2.default)(modelReference, tail);
+};
+var getValueForModelInstance = async (modelInstance, path) => {
+  const [head, tail] = createHeadAndTail(path.split("."), ".");
+  const value = await modelInstance.get[head]();
+  return tail ? (0, import_get2.default)(value, tail) : value;
+};
+var isReferencedProperty = (modelInstance, key) => {
+  return modelInstance.getReferences()[key];
+};
+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 isModelInstance = (obj) => {
+  return Boolean(obj && obj.getPrimaryKey);
+};
+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 MAX_YEAR = 3e3;
+var EMAIL_REGEX = /[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?/u;
+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 DateProperty = (config = {}, additionalMetadata = {}) => Property(
+  "Date" /* Date */,
+  (0, import_merge3.default)(
+    {
+      lazyLoadMethod: (value) => {
+        if (isDate2(value)) {
+          if (config.formatFunction) {
+            return config.formatFunction(value, config.format);
+          }
+          return value.toISOString().split("T")[0];
+        }
+        if (!value && config?.autoNow) {
+          const date = /* @__PURE__ */ new Date();
+          if (config.formatFunction) {
+            return config.formatFunction(date, config.format);
+          }
+          return date.toISOString().split("T")[0];
+        }
+        return value;
+      }
+    },
+    config
+  ),
+  additionalMetadata
+);
+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 ArrayProperty = (config = {}, additionalMetadata = {}) => Property(
+  "Array" /* Array */,
+  {
+    defaultValue: [],
+    ...config,
+    isArray: true
+  },
+  additionalMetadata
+);
+var SingleTypeArrayProperty = (valueType, config = {}, additionalMetadata = {}) => Property(
+  "Array" /* Array */,
+  {
+    defaultValue: [],
+    ...config,
+    isArray: true,
+    validators: mergeValidators(
+      config,
+      // @ts-ignore
+      arrayType(valueType)
+    )
+  },
+  additionalMetadata
+);
+var ObjectProperty = (config = {}, additionalMetadata = {}) => Property(
+  "Object" /* Object */,
+  (0, import_merge3.default)(config, {
+    validators: mergeValidators(config, isType("object"))
+  }),
+  additionalMetadata
+);
+var TextProperty = (config = {}, additionalMetadata = {}) => Property(
+  "Text" /* Text */,
+  (0, import_merge3.default)(config, {
+    isString: true,
+    // @ts-ignore
+    validators: mergeValidators(config, ...getCommonTextValidators(config))
+  }),
+  additionalMetadata
+);
+var BigTextProperty = (config = {}, additionalMetadata = {}) => Property(
+  "BigText" /* BigText */,
+  (0, import_merge3.default)(config, {
+    isString: true,
+    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 YearProperty = (config = {}, additionalMetadata = {}) => Property(
+  "Integer" /* Integer */,
+  (0, import_merge3.default)(config, {
+    isInteger: true,
+    validators: mergeValidators(
+      config,
+      ...getCommonNumberValidators(config),
+      minNumber(0),
+      maxNumber(MAX_YEAR)
+    )
+  }),
+  additionalMetadata
+);
+var NumberProperty = (config = {}, additionalMetadata = {}) => Property(
+  "Number" /* Number */,
+  (0, import_merge3.default)(config, {
+    isNumber: true,
+    validators: mergeValidators(config, ...getCommonNumberValidators(config))
+  }),
+  additionalMetadata
+);
+var ConstantValueProperty = (valueType, value, config = {}, additionalMetadata = {}) => Property(
+  valueType,
+  (0, import_merge3.default)(config, {
+    value
+  }),
+  additionalMetadata
+);
+var EmailProperty = (config = {}, additionalMetadata = {}) => TextProperty(
+  (0, import_merge3.default)(config, {
+    type: "Email" /* Email */,
+    validators: mergeValidators(config, meetsRegex(EMAIL_REGEX))
+  }),
+  additionalMetadata
+);
+var BooleanProperty = (config = {}, additionalMetadata = {}) => Property(
+  "Boolean" /* Boolean */,
+  (0, import_merge3.default)(config, {
+    isBoolean: true
+  }),
+  additionalMetadata
+);
+var PrimaryKeyUuidProperty = (config = {}, additionalMetadata = {}) => Property(
+  "UniqueId" /* UniqueId */,
+  (0, import_merge3.default)(config, {
+    required: true,
+    isString: true,
+    validators: mergeValidators(config, isValidUuid),
+    lazyLoadMethod: (value) => {
+      if (!value) {
+        return v4_default();
+      }
+      return value;
+    }
+  }),
+  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
+);
+var ModelReferenceProperty = (model, config = {}, additionalMetadata = {}) => AdvancedModelReferenceProperty(model, config, additionalMetadata);
+var AdvancedModelReferenceProperty = (model, config = {}, additionalMetadata = {}) => {
+  if (!model) {
+    throw new Error("Must include the referenced model");
+  }
+  const _getModel = () => {
+    if (typeof model === "function") {
+      return model();
+    }
+    return model;
+  };
+  const validator = referenceTypeMatch(model);
+  const validators = mergeValidators(config, validator);
+  const _getId = (instanceValues) => () => {
+    if (!instanceValues) {
+      return void 0;
+    }
+    if (typeof instanceValues === "number") {
+      return instanceValues;
+    }
+    if (typeof instanceValues === "string") {
+      return instanceValues;
+    }
+    if (instanceValues.getPrimaryKey) {
+      return instanceValues.getPrimaryKey();
+    }
+    const theModel = _getModel();
+    const primaryKey = theModel.getModelDefinition().primaryKeyName;
+    return instanceValues[primaryKey];
+  };
+  const lazyLoadMethodAtomic = async (instanceValues) => {
+    const valueIsModelInstance = isModelInstance(instanceValues);
+    const _getInstanceReturn = (objToUse) => {
+      const objIsModelInstance = isModelInstance(objToUse);
+      const instance = objIsModelInstance ? objToUse : (
+        // @ts-ignore
+        _getModel().create(objToUse)
+      );
+      return (0, import_merge3.default)({}, instance, {
+        toObj: memoizeAsync(_getId(instanceValues))
+      });
+    };
+    if (valueIsModelInstance) {
+      return _getInstanceReturn(instanceValues);
+    }
+    const theModel = _getModel();
+    const primaryKey = theModel.getModelDefinition().primaryKeyName;
+    if ((0, import_get3.default)(instanceValues, primaryKey)) {
+      return _getInstanceReturn(instanceValues);
+    }
+    if (config?.fetcher) {
+      const id = await _getId(instanceValues)();
+      const model2 = _getModel();
+      if (id !== null && id !== void 0) {
+        const obj = await config.fetcher(model2, id);
+        return _getInstanceReturn(obj);
+      }
+      return null;
+    }
+    return _getId(instanceValues)();
+  };
+  const p = (0, import_merge3.default)(
+    Property(
+      "ModelReference" /* ModelReference */,
+      (0, import_merge3.default)({}, config, {
+        validators,
+        lazyLoadMethodAtomic
+      }),
+      additionalMetadata
+    ),
+    {
+      getReferencedId: (instanceValues) => _getId(instanceValues)(),
+      getReferencedModel: _getModel
+    }
+  );
+  return p;
+};
+var DenormalizedProperty = (propertyType, calculate, config = {}, additionalMetadata = {}) => {
+  const property = Property(
+    propertyType,
+    (0, import_merge3.default)(config, {
+      isDenormalized: true,
+      lazyLoadMethodAtomic: async (value, modelData, modelInstance) => {
+        if (value !== void 0) {
+          return value;
+        }
+        return calculate(modelData, modelInstance);
+      }
+    }),
+    additionalMetadata
+  );
+  return (0, import_merge3.default)(property, {
+    calculate
+  });
+};
+var DenormalizedTextProperty = (calculate, config = {}, additionalMetadata = {}) => DenormalizedProperty(
+  "Text" /* Text */,
+  calculate,
+  (0, import_merge3.default)(config, {
+    isString: true,
+    validators: mergeValidators(
+      config,
+      ...getCommonTextValidators(config)
+    )
+  }),
+  additionalMetadata
+);
+var DenormalizedNumberProperty = (calculate, config = {}, additionalMetadata = {}) => DenormalizedProperty(
+  "Number" /* Number */,
+  calculate,
+  (0, import_merge3.default)(config, {
+    isNumber: true,
+    validators: mergeValidators(config, ...getCommonNumberValidators(config))
+  }),
+  additionalMetadata
+);
+var DenormalizedIntegerProperty = (calculate, config = {}, additionalMetadata = {}) => DenormalizedProperty(
+  "Integer" /* Integer */,
+  calculate,
+  (0, import_merge3.default)(config, {
+    isInteger: true,
+    validators: mergeValidators(config, ...getCommonNumberValidators(config))
+  }),
+  additionalMetadata
+);
+var NaturalIdProperty = (propertyKeys, joiner, config = {}, additionalMetadata = {}) => Property(
+  "Text" /* Text */,
+  (0, import_merge3.default)(config, {
+    isString: true,
+    validators: mergeValidators(config, ...getCommonTextValidators(config)),
+    lazyLoadMethodAtomic: async (value, model, modelInstance) => {
+      const data = await propertyKeys.reduce(async (accP, key) => {
+        const acc = await accP;
+        const [head] = createHeadAndTail(key.split("."), ".");
+        const value2 = await (isReferencedProperty(modelInstance, head) ? getValueForReferencedModel(modelInstance, key) : getValueForModelInstance(modelInstance, key));
+        return acc.concat(value2);
+      }, Promise.resolve([]));
+      if (data.some((value2) => value2 === void 0)) {
+        return void 0;
+      }
+      return data.join(joiner);
+    }
+  }),
+  additionalMetadata
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AdvancedModelReferenceProperty,
+  ArrayProperty,
+  BigTextProperty,
+  BooleanProperty,
+  ConstantValueProperty,
+  DateProperty,
+  DatetimeProperty,
+  DenormalizedIntegerProperty,
+  DenormalizedNumberProperty,
+  DenormalizedProperty,
+  DenormalizedTextProperty,
+  EmailProperty,
+  IntegerProperty,
+  ModelReferenceProperty,
+  NaturalIdProperty,
+  NumberProperty,
+  ObjectProperty,
+  PrimaryKeyUuidProperty,
+  Property,
+  SingleTypeArrayProperty,
+  TextProperty,
+  UuidProperty,
+  YearProperty
+});
+//# sourceMappingURL=properties.cjs.map