functional-models 3.9.5 → 3.11.0

package/cjs/orm/index.cjs

@@ -0,0 +1,1765 @@
+"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/index.ts
+var orm_exports = {};
+__export(orm_exports, {
+  AllowableEqualitySymbols: () => AllowableEqualitySymbols,
+  DatastoreValueType: () => DatastoreValueType,
+  EqualitySymbol: () => EqualitySymbol,
+  ForeignKeyProperty: () => ForeignKeyProperty,
+  LastModifiedDateProperty: () => LastModifiedDateProperty,
+  PrimaryKeyProperty: () => PrimaryKeyProperty,
+  SortOrder: () => SortOrder,
+  and: () => and,
+  booleanQuery: () => booleanQuery,
+  buildOrmValidatorContext: () => buildOrmValidatorContext,
+  createOrm: () => createOrm,
+  datesAfter: () => datesAfter,
+  datesBefore: () => datesBefore,
+  isALinkToken: () => isALinkToken,
+  isPropertyBasedQuery: () => isPropertyBasedQuery,
+  numberQuery: () => numberQuery,
+  or: () => or,
+  ormPropertyConfig: () => ormPropertyConfig,
+  pagination: () => pagination,
+  properties: () => properties_exports,
+  property: () => property,
+  query: () => query_exports,
+  queryBuilder: () => queryBuilder,
+  sort: () => sort,
+  take: () => take,
+  textQuery: () => textQuery,
+  threeitize: () => threeitize,
+  types: () => types_exports,
+  unique: () => unique,
+  uniqueTogether: () => uniqueTogether,
+  validateOrmSearch: () => validateOrmSearch,
+  validation: () => validation_exports
+});
+module.exports = __toCommonJS(orm_exports);
+
+// src/orm/query.ts
+var query_exports = {};
+__export(query_exports, {
+  and: () => and,
+  booleanQuery: () => booleanQuery,
+  datesAfter: () => datesAfter,
+  datesBefore: () => datesBefore,
+  isALinkToken: () => isALinkToken,
+  isPropertyBasedQuery: () => isPropertyBasedQuery,
+  numberQuery: () => numberQuery,
+  or: () => or,
+  pagination: () => pagination,
+  property: () => property,
+  queryBuilder: () => queryBuilder,
+  sort: () => sort,
+  take: () => take,
+  textQuery: () => textQuery,
+  threeitize: () => threeitize,
+  validateOrmSearch: () => validateOrmSearch
+});
+var import_merge = __toESM(require("lodash/merge.js"), 1);
+var import_omit = __toESM(require("lodash/omit.js"), 1);
+
+// src/orm/types.ts
+var types_exports = {};
+__export(types_exports, {
+  AllowableEqualitySymbols: () => AllowableEqualitySymbols,
+  DatastoreValueType: () => DatastoreValueType,
+  EqualitySymbol: () => EqualitySymbol,
+  SortOrder: () => SortOrder
+});
+var EqualitySymbol = /* @__PURE__ */ ((EqualitySymbol2) => {
+  EqualitySymbol2["eq"] = "=";
+  EqualitySymbol2["lt"] = "<";
+  EqualitySymbol2["lte"] = "<=";
+  EqualitySymbol2["gt"] = ">";
+  EqualitySymbol2["gte"] = ">=";
+  EqualitySymbol2["ne"] = "!=";
+  return EqualitySymbol2;
+})(EqualitySymbol || {});
+var DatastoreValueType = /* @__PURE__ */ ((DatastoreValueType2) => {
+  DatastoreValueType2["string"] = "string";
+  DatastoreValueType2["number"] = "number";
+  DatastoreValueType2["date"] = "date";
+  DatastoreValueType2["object"] = "object";
+  DatastoreValueType2["boolean"] = "boolean";
+  return DatastoreValueType2;
+})(DatastoreValueType || {});
+var AllowableEqualitySymbols = Object.values(EqualitySymbol);
+var SortOrder = /* @__PURE__ */ ((SortOrder2) => {
+  SortOrder2["asc"] = "asc";
+  SortOrder2["dsc"] = "dsc";
+  return SortOrder2;
+})(SortOrder || {});
+
+// src/orm/query.ts
+var THREE = 3;
+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_merge.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_merge.default)(data, {
+          query: data.query.concat(queryTokens)
+        })
+      );
+    }
+    return _link((0, import_merge.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_merge.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_merge.default)(data, { query: data.query.concat(p) }));
+  };
+  return {
+    datesBefore: thisDatesBefore,
+    datesAfter: thisDatesAfter,
+    complex,
+    property: _myProperty
+  };
+};
+var _queryBuilder = (data = void 0) => {
+  const theData = (0, import_merge.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: isDate(jsDate) ? jsDate.toISOString() : jsDate,
+    valueType,
+    options: {
+      equalToAndAfter
+    }
+  };
+};
+var isDate = (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: isDate(jsDate) ? jsDate.toISOString() : jsDate,
+    valueType,
+    options: {
+      equalToAndBefore
+    }
+  };
+};
+var queryBuilder = () => {
+  return _queryBuilder();
+};
+var isPropertyBasedQuery = (value) => {
+  if (!value || !value.type) {
+    return false;
+  }
+  return value.type === "property" || value.type === "datesBefore" || value.type === "datesAfter";
+};
+var isALinkToken = (value) => {
+  if (!value) {
+    return false;
+  }
+  if (typeof value !== "string") {
+    return false;
+  }
+  value = value.toLowerCase();
+  return value === "and" || value === "or";
+};
+var and = () => "AND";
+var or = () => "OR";
+var textQuery = (key, value, options) => property(
+  key,
+  value,
+  Object.assign({}, options, {
+    equalitySymbol: void 0,
+    type: "string" /* string */
+  })
+);
+var numberQuery = (key, value, equalitySymbol = "=" /* eq */) => property(key, value, {
+  equalitySymbol,
+  type: "number" /* number */
+});
+var booleanQuery = (key, value) => property(key, value, {
+  type: "boolean" /* boolean */,
+  equalitySymbol: "=" /* eq */
+});
+var threeitize = (data) => {
+  if (data.length === 0 || data.length === 1) {
+    return [];
+  }
+  if (data.length % 2 === 0) {
+    throw new Error("Must be an odd number of 3 or greater.");
+  }
+  const three = data.slice(0, THREE);
+  const rest = data.slice(2);
+  const moreThrees = threeitize(rest);
+  return [three, ...moreThrees];
+};
+var _validateTokenTypes = (token) => {
+  if (Array.isArray(token)) {
+    token.forEach(_validateTokenTypes);
+    return;
+  }
+  if (isPropertyBasedQuery(token)) {
+    return;
+  }
+  if (isALinkToken(token)) {
+    return;
+  }
+  throw new Error(`Unknown token type ${token}`);
+};
+var _validateTokenStructure = (o) => {
+  const first = o[0];
+  if (first === "AND" || first === "OR") {
+    throw new Error("Cannot have AND or OR at the very start.");
+  }
+  const last = o[o.length - 1];
+  if (last === "AND" || last === "OR") {
+    throw new Error("Cannot have AND or OR at the very end.");
+  }
+  if (o.every((x) => x !== "AND" && x !== "OR")) {
+    o.every(_validateArrayOrQuery);
+    return;
+  }
+  const totalLinks = o.filter((x) => x === "AND" || x === "OR");
+  const nonLinks = o.filter((x) => x !== "AND" && x !== "OR");
+  if (totalLinks.length !== nonLinks.length - 1) {
+    throw new Error("Must separate each statement with an AND or OR");
+  }
+  const threes = threeitize(o).reverse();
+  threes.forEach(([a, l, b]) => {
+    if (l !== "AND" && l !== "OR") {
+      if (isPropertyBasedQuery(l)) {
+        throw new Error("Must have AND/OR between property queries");
+      }
+      throw new Error("Must have AND/OR between nested queries");
+    }
+    _validateArrayOrQuery(a);
+    _validateArrayOrQuery(b);
+  });
+  return;
+};
+var _validateArrayOrQuery = (o) => {
+  if (Array.isArray(o)) {
+    _validateTokenStructure(o);
+    return;
+  }
+  if (isPropertyBasedQuery(o)) {
+    return;
+  }
+  throw new Error("Order of link tokens and queries invalid");
+};
+var validateOrmSearch = (search) => {
+  if (Array.isArray(search.query) === false) {
+    throw new Error(`Query must be an array`);
+  }
+  if (search.query.length < 1) {
+    return;
+  }
+  _validateTokenTypes(search.query);
+  _validateTokenStructure(search.query);
+};
+
+// src/orm/validation.ts
+var validation_exports = {};
+__export(validation_exports, {
+  buildOrmValidatorContext: () => buildOrmValidatorContext,
+  unique: () => unique,
+  uniqueTogether: () => uniqueTogether
+});
+var import_flow = __toESM(require("lodash/flow.js"), 1);
+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_flow.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;
+};
+var buildOrmValidatorContext = ({
+  noOrmValidation = false
+}) => ({
+  noOrmValidation
+});
+
+// src/orm/properties.ts
+var properties_exports = {};
+__export(properties_exports, {
+  ForeignKeyProperty: () => ForeignKeyProperty,
+  LastModifiedDateProperty: () => LastModifiedDateProperty,
+  PrimaryKeyProperty: () => PrimaryKeyProperty,
+  ormPropertyConfig: () => ormPropertyConfig
+});
+var import_merge5 = __toESM(require("lodash/merge.js"), 1);
+var import_identity = __toESM(require("lodash/identity.js"), 1);
+
+// src/types.ts
+var ApiMethod = /* @__PURE__ */ ((ApiMethod2) => {
+  ApiMethod2["create"] = "create";
+  ApiMethod2["retrieve"] = "retrieve";
+  ApiMethod2["update"] = "update";
+  ApiMethod2["delete"] = "delete";
+  ApiMethod2["search"] = "search";
+  return ApiMethod2;
+})(ApiMethod || {});
+
+// src/properties.ts
+var import_merge4 = __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_merge2 = __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 toTitleCase = (string) => {
+  return `${string.slice(0, 1).toUpperCase()}${string.slice(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 singularize = (word) => {
+  return word.replace(_singularizingRe, (r) => PluralEndings[r]);
+};
+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 isDate2 = (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 (isDate2(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 createModelValidator = (validators, modelValidators) => {
+  const _modelValidator = async (instance, propertyConfiguration) => {
+    return Promise.resolve().then(async () => {
+      if (!instance) {
+        throw new Error(`Instance cannot be empty`);
+      }
+      const model = instance.getModel();
+      const keysAndFunctions = Object.entries(validators);
+      const instanceData = await instance.toObj();
+      const propertyValidationErrors = await Promise.all(
+        keysAndFunctions.map(async ([key, validator]) => {
+          return [
+            key,
+            await validator(model, instanceData, propertyConfiguration)
+          ];
+        })
+      );
+      const modelValidationErrors = (await Promise.all(
+        modelValidators ? modelValidators.map((validator) => {
+          return validator(model, instanceData, propertyConfiguration);
+        }) : []
+      )).filter((x) => x);
+      const propertyErrors = propertyValidationErrors.filter(([, errors]) => Boolean(errors) && errors.length > 0).reduce((acc, [key, errors]) => {
+        return (0, import_merge2.default)(acc, { [String(key)]: errors });
+      }, {});
+      const final = modelValidationErrors.length > 0 ? (0, import_merge2.default)(propertyErrors, { overall: modelValidationErrors }) : propertyErrors;
+      if ((0, import_isEmpty.default)(final)) {
+        return void 0;
+      }
+      return final;
+    });
+  };
+  return _modelValidator;
+};
+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_flow2 = __toESM(require("lodash/flow.js"), 1);
+var import_merge3 = __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_ENDPOINT = "NULL";
+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 getModelName = (namespace, pluralName) => {
+  return `${namespace}/${pluralName}`;
+};
+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 getNullRestInfo = () => {
+  return {
+    endpoint: NULL_ENDPOINT,
+    method: NULL_METHOD,
+    security: {}
+  };
+};
+var _fillOutRestInfo = (pluralName, namespace, partial, nullRest) => {
+  const finishedRestInfo = Object.entries(
+    ApiMethod
+  ).reduce(
+    (acc, [, method]) => {
+      const existing = partial && partial.rest && partial.rest[method] ? partial.rest[method] : void 0;
+      const restInfo = _apiMethodToRestInfoGenerator[method](
+        pluralName,
+        namespace
+      )(existing);
+      return (0, import_merge3.default)(acc, {
+        [method]: restInfo
+      });
+    },
+    nullRest
+  );
+  return {
+    noPublish: false,
+    onlyPublish: [],
+    rest: finishedRestInfo,
+    createOnlyOne: partial?.createOnlyOne || false
+  };
+};
+var populateApiInformation = (pluralName, namespace, partial) => {
+  const nullRest = {
+    delete: getNullRestInfo(),
+    search: getNullRestInfo(),
+    update: getNullRestInfo(),
+    retrieve: getNullRestInfo(),
+    create: getNullRestInfo()
+  };
+  if (!partial) {
+    return _fillOutRestInfo(pluralName, namespace, partial, nullRest);
+  }
+  if (partial.noPublish) {
+    return {
+      onlyPublish: [],
+      noPublish: true,
+      rest: nullRest,
+      createOnlyOne: false
+    };
+  }
+  const rest = partial.rest || {};
+  if (partial.onlyPublish && partial.onlyPublish.length > 0) {
+    return partial.onlyPublish.reduce(
+      (acc, method) => {
+        const restInfo = _apiMethodToRestInfoGenerator[method](
+          pluralName,
+          namespace
+        )(rest[method]);
+        return (0, import_merge3.default)(acc, {
+          rest: {
+            [method]: restInfo
+          }
+        });
+      },
+      {
+        noPublish: false,
+        onlyPublish: partial.onlyPublish,
+        createOnlyOne: Boolean(partial.createOnlyOne),
+        rest: nullRest
+      }
+    );
+  }
+  return _fillOutRestInfo(pluralName, namespace, partial, nullRest);
+};
+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_flow2.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 isDate3 = (value) => {
+  if (value === null) {
+    return false;
+  }
+  return typeof value === "object" && value.toISOString;
+};
+var DatetimeProperty = (config = {}, additionalMetadata = {}) => Property(
+  "Datetime" /* Datetime */,
+  (0, import_merge4.default)(
+    {
+      lazyLoadMethod: (value) => {
+        if (isDate3(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_merge4.default)(config, {
+    isString: true,
+    // @ts-ignore
+    validators: mergeValidators(config, ...getCommonTextValidators(config))
+  }),
+  additionalMetadata
+);
+var IntegerProperty = (config = {}, additionalMetadata = {}) => Property(
+  "Integer" /* Integer */,
+  (0, import_merge4.default)(config, {
+    isInteger: true,
+    validators: mergeValidators(
+      config,
+      ...getCommonNumberValidators(config)
+    )
+  }),
+  additionalMetadata
+);
+var UuidProperty = (config = {}, additionalMetadata = {}) => Property(
+  "UniqueId" /* UniqueId */,
+  (0, import_merge4.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/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)
+  });
+};
+
+// src/orm/models.ts
+var import_merge8 = __toESM(require("lodash/merge.js"), 1);
+var import_modern_async = require("modern-async");
+
+// src/models.ts
+var import_merge7 = __toESM(require("lodash/merge.js"), 1);
+var import_zod2 = __toESM(require("zod"), 1);
+
+// src/serialization.ts
+var import_merge6 = __toESM(require("lodash/merge.js"), 1);
+var isModelInstance2 = (obj) => {
+  return Boolean(obj.toObj);
+};
+var _getValue = async (value) => {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (value === null) {
+    return null;
+  }
+  const type = typeof value;
+  const asFunction = value;
+  if (type === "function") {
+    return _getValue(await asFunction());
+  }
+  if (isModelInstance2(value)) {
+    return _getValue(await value.toObj());
+  }
+  const asDate = value;
+  if (type === "object" && asDate.toISOString) {
+    return _getValue(asDate.toISOString());
+  }
+  return value;
+};
+var toJsonAble = (keyToFunc) => () => {
+  return Object.entries(keyToFunc).reduce(async (acc, [key, value]) => {
+    const realAcc = await acc;
+    const trueValue = await _getValue(await value);
+    if (trueValue === void 0) {
+      return realAcc;
+    }
+    return (0, import_merge6.default)(realAcc, { [key]: trueValue });
+  }, Promise.resolve({}));
+};
+
+// src/models.ts
+var _defaultOptions = () => ({
+  instanceCreatedCallback: void 0
+});
+var _convertOptions = (options) => {
+  const r = (0, import_merge7.default)({}, _defaultOptions(), options);
+  return r;
+};
+var _addDescription = (schema, description) => {
+  if (!description) {
+    return schema;
+  }
+  if (typeof schema.openapi === "function") {
+    return schema.openapi({ description });
+  }
+  return schema.meta ? schema.meta({ description }) : schema.describe(description);
+};
+var _createZod = (modelDefinition) => {
+  if (modelDefinition.schema) {
+    return _addDescription(modelDefinition.schema, modelDefinition.description);
+  }
+  const properties = Object.entries(modelDefinition.properties).reduce(
+    (acc, [key, property2]) => {
+      const asProp = property2;
+      return (0, import_merge7.default)(acc, {
+        [key]: asProp.getZod()
+      });
+    },
+    {}
+  );
+  const obj = import_zod2.default.object(properties);
+  return _addDescription(obj, modelDefinition.description);
+};
+var _toModelDefinition = (minimal) => {
+  return {
+    singularName: singularize(minimal.pluralName),
+    displayName: toTitleCase(minimal.pluralName),
+    description: "",
+    primaryKeyName: "id",
+    modelValidators: [],
+    schema: _createZod(minimal),
+    ...minimal
+  };
+};
+var _validateModelDefinition = (modelDefinition) => {
+  const primaryKeyName = modelDefinition.primaryKeyName || "id";
+  const primaryKeyProperty = (
+    // @ts-ignore
+    modelDefinition.properties[primaryKeyName]
+  );
+  if (!primaryKeyProperty) {
+    throw new Error(`Property missing for primaryKey named ${primaryKeyName}`);
+  }
+  if (!modelDefinition.pluralName) {
+    throw new Error(`Must include pluralName for model.`);
+  }
+  if (!modelDefinition.namespace) {
+    throw new Error(`Must include namespace for model.`);
+  }
+};
+var Model = (minimalModelDefinitions, options) => {
+  _validateModelDefinition(minimalModelDefinitions);
+  let model = null;
+  const theOptions = _convertOptions(options);
+  const modelDefinition = _toModelDefinition(minimalModelDefinitions);
+  const getPrimaryKeyName = () => modelDefinition.primaryKeyName;
+  const getPrimaryKey = (loadedInternals) => {
+    const property2 = loadedInternals.get[getPrimaryKeyName()];
+    return property2();
+  };
+  const create = (instanceValues) => {
+    let instance = null;
+    const startingInternals = {
+      get: {},
+      validators: {},
+      references: {}
+    };
+    const prop = Object.entries(
+      modelDefinition.properties
+    );
+    const loadedInternals = prop.reduce(
+      (acc, [key, property2]) => {
+        const propertyGetter = memoizeSync(
+          () => property2.createGetter(
+            //@ts-ignore
+            instanceValues[key],
+            instanceValues,
+            // NOTE: By the time it gets here, it has already been implemented.
+            instance
+          )()
+        );
+        const propertyValidator = property2.getValidator(propertyGetter);
+        const fleshedOutInstanceProperties = {
+          get: {
+            [key]: () => propertyGetter()
+          },
+          validators: {
+            [key]: propertyValidator
+          }
+        };
+        const asReferenced = property2;
+        const referencedProperty = asReferenced.getReferencedId ? {
+          references: {
+            [key]: () => asReferenced.getReferencedId(
+              // @ts-ignore
+              instanceValues[key]
+            )
+          }
+        } : {};
+        return (0, import_merge7.default)(
+          acc,
+          fleshedOutInstanceProperties,
+          referencedProperty
+        );
+      },
+      startingInternals
+    );
+    const getModel = () => model;
+    const toObj = memoizeAsync(() => {
+      return toJsonAble(loadedInternals.get)();
+    });
+    const validate = memoizeAsync((options2 = {}) => {
+      return Promise.resolve().then(() => {
+        return createModelValidator(
+          loadedInternals.validators,
+          modelDefinition.modelValidators
+        )(instance, options2);
+      });
+    });
+    const getReferences = () => loadedInternals.references;
+    const getValidators = () => loadedInternals.validators;
+    instance = {
+      get: loadedInternals.get,
+      getReferences,
+      getValidators,
+      getModel,
+      toObj,
+      getPrimaryKey: () => getPrimaryKey(loadedInternals),
+      validate
+    };
+    if (theOptions.instanceCreatedCallback) {
+      const toCall = Array.isArray(theOptions.instanceCreatedCallback) ? theOptions.instanceCreatedCallback : [theOptions.instanceCreatedCallback];
+      toCall.map((func) => func(instance));
+    }
+    return instance;
+  };
+  const getApiInfo = memoizeSync(() => {
+    return populateApiInformation(
+      modelDefinition.pluralName,
+      modelDefinition.namespace,
+      modelDefinition.api
+    );
+  });
+  model = {
+    /**
+     * Creates a model instance.
+     */
+    create,
+    getName: () => getModelName(modelDefinition.namespace, modelDefinition.pluralName),
+    getModelDefinition: memoizeSync(() => modelDefinition),
+    getPrimaryKey,
+    getApiInfo
+  };
+  return model;
+};
+
+// src/errors.ts
+var ValidationError = class extends Error {
+  constructor(modelName, keysToErrors) {
+    super(`${modelName} did not pass validation`);
+    this.name = "ValidationError";
+    this.modelName = modelName;
+    this.keysToErrors = keysToErrors;
+  }
+};
+
+// src/orm/models.ts
+var createOrm = ({
+  datastoreAdapter,
+  Model: Model2 = Model
+}) => {
+  if (!datastoreAdapter) {
+    throw new Error(`Must include a datastoreAdapter`);
+  }
+  const _retrievedObjToModel = (model) => (obj) => {
+    return model.create(obj);
+  };
+  const fetcher = async (model, id) => {
+    const x = retrieve(
+      model,
+      id
+    );
+    return x;
+  };
+  const retrieve = async (model, id) => {
+    const obj = await datastoreAdapter.retrieve(model, id);
+    if (!obj) {
+      return void 0;
+    }
+    return _retrievedObjToModel(model)(obj);
+  };
+  const _defaultOptions2 = () => ({
+    instanceCreatedCallback: void 0
+  });
+  const _convertOptions2 = (options) => {
+    const r = (0, import_merge8.default)(
+      {},
+      _defaultOptions2(),
+      options
+    );
+    return r;
+  };
+  const ThisModel = (modelDefinition, options) => {
+    let model = null;
+    const theOptions = _convertOptions2(options);
+    const search = (ormQuery) => {
+      return datastoreAdapter.search(model, ormQuery).then((result) => {
+        const conversionFunc = _retrievedObjToModel(model);
+        return {
+          // @ts-ignore
+          instances: result.instances.map(conversionFunc),
+          page: result.page
+        };
+      });
+    };
+    const searchOne = (ormQuery) => {
+      ormQuery = (0, import_merge8.default)(ormQuery, { take: 1 });
+      return search(ormQuery).then(({ instances }) => {
+        return instances[0];
+      });
+    };
+    const bulkInsert = async (instances) => {
+      if (datastoreAdapter.bulkInsert) {
+        await datastoreAdapter.bulkInsert(model, instances);
+        return void 0;
+      }
+      await (0, import_modern_async.asyncMap)(instances, (x) => x.save());
+      return void 0;
+    };
+    const bulkDelete = async (keysOrInstances) => {
+      const ids = typeof keysOrInstances[0] === "object" ? keysOrInstances.map(
+        (x) => x.getPrimaryKey()
+      ) : keysOrInstances;
+      if (datastoreAdapter.bulkDelete) {
+        await datastoreAdapter.bulkDelete(model, ids);
+        return void 0;
+      }
+      await (0, import_modern_async.asyncMap)(ids, (id) => model.delete(id));
+      return void 0;
+    };
+    const loadedRetrieve = (id) => {
+      return retrieve(model, id);
+    };
+    const modelValidators = modelDefinition?.uniqueTogether ? (modelDefinition.modelValidators || []).concat(
+      // @ts-ignore
+      uniqueTogether(modelDefinition.uniqueTogether)
+    ) : modelDefinition.modelValidators;
+    const ormModelDefinition = (0, import_merge8.default)({}, modelDefinition, {
+      modelValidators
+    });
+    const _updateLastModifiedIfExistsReturnNewObj = async (instance) => {
+      const hasLastModified = Object.entries(
+        instance.getModel().getModelDefinition().properties
+      ).filter((propertyEntry) => {
+        const property2 = propertyEntry[1];
+        return Boolean("lastModifiedUpdateMethod" in property2);
+      })[0];
+      const doLastModified = async () => {
+        const obj = await instance.toObj();
+        const newInstance = model.create(
+          // @ts-ignore
+          (0, import_merge8.default)(obj, {
+            [hasLastModified[0]]: (
+              // @ts-ignore
+              hasLastModified[1].lastModifiedUpdateMethod()
+            )
+          })
+        );
+        return newInstance;
+      };
+      return hasLastModified ? doLastModified() : instance;
+    };
+    const save = async (instance) => {
+      return Promise.resolve().then(async () => {
+        const newInstance = await _updateLastModifiedIfExistsReturnNewObj(instance);
+        const invalid = await newInstance.validate();
+        if (invalid) {
+          throw new ValidationError(model.getName(), invalid);
+        }
+        const savedObj = await datastoreAdapter.save(newInstance);
+        return _retrievedObjToModel(model)(savedObj);
+      });
+    };
+    const createAndSave = async (data) => {
+      if (datastoreAdapter.createAndSave) {
+        const response = await datastoreAdapter.createAndSave(data);
+        return _retrievedObjToModel(model)(response);
+      }
+      const instance = model.create(await data.toObj());
+      return instance.save();
+    };
+    const deleteObj = (id) => {
+      return Promise.resolve().then(async () => {
+        await datastoreAdapter.delete(model, id);
+      });
+    };
+    const _getSave = (instance) => {
+      if (theOptions.save !== void 0) {
+        return () => theOptions.save(save, instance);
+      }
+      return () => save(instance);
+    };
+    const _getDelete = (instance) => {
+      if (theOptions.delete) {
+        return () => theOptions.delete(deleteObj, instance);
+      }
+      return () => deleteObj(instance.getPrimaryKey());
+    };
+    const instanceCreatedCallback = (instance) => {
+      instance.save = _getSave(instance);
+      instance.delete = _getDelete(instance);
+      if (theOptions.instanceCreatedCallback) {
+        const callbacks = Array.isArray(theOptions.instanceCreatedCallback) ? theOptions.instanceCreatedCallback : [theOptions.instanceCreatedCallback];
+        callbacks.forEach((x) => x(instance));
+      }
+    };
+    const overridedOptions = (0, import_merge8.default)({}, theOptions, {
+      instanceCreatedCallback: [instanceCreatedCallback]
+    });
+    const baseModel = Model2(ormModelDefinition, overridedOptions);
+    const lowerLevelCreate = baseModel.create;
+    const _convertModelInstance = (instance) => {
+      return (0, import_merge8.default)(instance, {
+        create,
+        getModel: () => model,
+        save: _getSave(instance),
+        delete: _getDelete(instance)
+      });
+    };
+    const create = (data) => {
+      const result = lowerLevelCreate(data);
+      return _convertModelInstance(result);
+    };
+    const _countRecursive = async (page = null) => {
+      const results = await model.search(
+        queryBuilder().pagination(page).compile()
+      );
+      const length1 = results.instances.length;
+      if (results.page && results.page !== page) {
+        const length2 = await _countRecursive(results.page);
+        return length1 + length2;
+      }
+      return length1;
+    };
+    const count = async () => {
+      if (datastoreAdapter.count) {
+        return datastoreAdapter.count(model);
+      }
+      return _countRecursive();
+    };
+    model = (0, import_merge8.default)(baseModel, {
+      create,
+      save,
+      delete: deleteObj,
+      retrieve: loadedRetrieve,
+      search,
+      searchOne,
+      createAndSave,
+      bulkInsert,
+      bulkDelete,
+      count
+    });
+    return model;
+  };
+  return {
+    Model: ThisModel,
+    fetcher
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AllowableEqualitySymbols,
+  DatastoreValueType,
+  EqualitySymbol,
+  ForeignKeyProperty,
+  LastModifiedDateProperty,
+  PrimaryKeyProperty,
+  SortOrder,
+  and,
+  booleanQuery,
+  buildOrmValidatorContext,
+  createOrm,
+  datesAfter,
+  datesBefore,
+  isALinkToken,
+  isPropertyBasedQuery,
+  numberQuery,
+  or,
+  ormPropertyConfig,
+  pagination,
+  properties,
+  property,
+  query,
+  queryBuilder,
+  sort,
+  take,
+  textQuery,
+  threeitize,
+  types,
+  unique,
+  uniqueTogether,
+  validateOrmSearch,
+  validation
+});
+//# sourceMappingURL=index.cjs.map