functional-models 3.9.5 → 3.11.0

package/cjs/models.cjs

@@ -0,0 +1,571 @@
+"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/models.ts
+var models_exports = {};
+__export(models_exports, {
+  Model: () => Model,
+  isNullRestInfo: () => isNullRestInfo,
+  noFetch: () => noFetch
+});
+module.exports = __toCommonJS(models_exports);
+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 flow2 = flowFindFirst(
+    validators
+  );
+  return flow2;
+};
+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, property]) => {
+      const asProp = property;
+      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 property = loadedInternals.get[getPrimaryKeyName()];
+    return property();
+  };
+  const create = (instanceValues) => {
+    let instance = null;
+    const startingInternals = {
+      get: {},
+      validators: {},
+      references: {}
+    };
+    const prop = Object.entries(
+      modelDefinition.properties
+    );
+    const loadedInternals = prop.reduce(
+      (acc, [key, property]) => {
+        const propertyGetter = memoizeSync(
+          () => property.createGetter(
+            //@ts-ignore
+            instanceValues[key],
+            instanceValues,
+            // NOTE: By the time it gets here, it has already been implemented.
+            instance
+          )()
+        );
+        const propertyValidator = property.getValidator(propertyGetter);
+        const fleshedOutInstanceProperties = {
+          get: {
+            [key]: () => propertyGetter()
+          },
+          validators: {
+            [key]: propertyValidator
+          }
+        };
+        const asReferenced = property;
+        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;
+};
+var isNullRestInfo = (restInfo) => {
+  return restInfo.method === NULL_METHOD && restInfo.endpoint === NULL_ENDPOINT;
+};
+var noFetch = () => {
+  return Promise.resolve(void 0);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Model,
+  isNullRestInfo,
+  noFetch
+});
+//# sourceMappingURL=models.cjs.map