functional-models 3.10.0 → 3.11.0

package/cjs/orm/models.cjs

@@ -0,0 +1,1027 @@
+"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/models.ts
+var models_exports = {};
+__export(models_exports, {
+  createOrm: () => createOrm
+});
+module.exports = __toCommonJS(models_exports);
+var import_merge6 = __toESM(require("lodash/merge.js"), 1);
+var import_modern_async = require("modern-async");
+
+// src/models.ts
+var import_merge4 = __toESM(require("lodash/merge.js"), 1);
+var import_zod2 = __toESM(require("zod"), 1);
+
+// src/serialization.ts
+var import_merge = __toESM(require("lodash/merge.js"), 1);
+var isModelInstance = (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 (isModelInstance(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_merge.default)(realAcc, { [key]: trueValue });
+  }, Promise.resolve({}));
+};
+
+// 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/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/utils.ts
+var import_async_lock = __toESM(require("async-lock"), 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/utils.ts
+var import_get_random_values = __toESM(require("get-random-values"), 1);
+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;
+    });
+  };
+};
+
+// src/validation.ts
+var multiValidator = (validators) => {
+  const flow3 = flowFindFirst(
+    validators
+  );
+  return flow3;
+};
+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 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;
+};
+
+// 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_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 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);
+};
+
+// src/models.ts
+var _defaultOptions = () => ({
+  instanceCreatedCallback: void 0
+});
+var _convertOptions = (options) => {
+  const r = (0, import_merge4.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_merge4.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_merge4.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/validation.ts
+var import_flow2 = __toESM(require("lodash/flow.js"), 1);
+
+// src/orm/query.ts
+var import_merge5 = __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_merge5.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_merge5.default)(data, {
+          query: data.query.concat(queryTokens)
+        })
+      );
+    }
+    return _link((0, import_merge5.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_merge5.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_merge5.default)(data, { query: data.query.concat(p) }));
+  };
+  return {
+    datesBefore: thisDatesBefore,
+    datesAfter: thisDatesAfter,
+    complex,
+    property: _myProperty
+  };
+};
+var _queryBuilder = (data = void 0) => {
+  const theData = (0, import_merge5.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();
+};
+
+// 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;
+};
+
+// 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_merge6.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_merge6.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_merge6.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_merge6.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_merge6.default)({}, theOptions, {
+      instanceCreatedCallback: [instanceCreatedCallback]
+    });
+    const baseModel = Model2(ormModelDefinition, overridedOptions);
+    const lowerLevelCreate = baseModel.create;
+    const _convertModelInstance = (instance) => {
+      return (0, import_merge6.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_merge6.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 = {
+  createOrm
+});
+//# sourceMappingURL=models.cjs.map