@nhtio/lucid-resourceful 0.1.0-master-1570171e → 0.1.0-master-3ec631a4

package/{decorator_utils-YSb1EGJ6.js → decorator_utils-gyymixlk.js}

@@ -1,4 +1,7 @@
-import { a as E_UNCASTABLE, b as E_INVALID_PREPARED_VALUE, c as E_INVALID_CONSUMED_VALUE } from "./errors-B1rr67uM.js";
+import { s as stripUndefinedValuesFromObject, a as E_UNCASTABLE, b as E_INVALID_PREPARED_VALUE, c as E_INVALID_CONSUMED_VALUE, i as isString$1 } from "./errors-C-x5_jRE.js";
+import { types } from "node:util";
+import { joi as zu } from "./joi.mjs";
+import { R as ResourcefulStringTypeSchema, a as ResourcefulDateTypeSchema, b as ResourcefulDateTimeTypeSchema, c as ResourcefulBinaryTypeSchema, d as ResourcefulNumberTypeSchema, e as ResourcefulIntegerTypeSchema, f as ResourcefulBigintTypeSchema, g as ResourcefulUnsignedIntegerTypeSchema, h as ResourcefulBooleanTypeSchema, i as ResourcefulObjectTypeSchema, j as ResourcefulArrayTypeSchema } from "./data_type_schemas-Cpco9Zba.js";
 class LuxonError extends Error {
 }
 class InvalidDateTimeError extends LuxonError {
@@ -1095,7 +1098,7 @@ function normalizeZone(input, defaultZone2) {
     return defaultZone2;
   } else if (input instanceof Zone) {
     return input;
-  } else if (isString$1(input)) {
+  } else if (isString(input)) {
     const lowered = input.toLowerCase();
     if (lowered === "default") return defaultZone2;
     else if (lowered === "local" || lowered === "system") return SystemZone.instance;
@@ -1491,7 +1494,7 @@ function isNumber(o) {
 function isInteger(o) {
   return typeof o === "number" && o % 1 === 0;
 }
-function isString$1(o) {
+function isString(o) {
   return typeof o === "string";
 }
 function isDate(o) {
@@ -6387,8 +6390,168 @@ const isInstanceOf = (value, type, ctor) => {
 };
 const isResourcefulModel = (value) => {
   if (!isObject(value) && !(typeof value === "function")) return false;
-  const proto = Object.getPrototypeOf(value);
-  return (isObject(proto) || typeof proto === "function") && "$resourcefulName" in proto && "string" === typeof proto.$resourcefulName && "$resourcefulColumns" in proto && proto.$resourcefulColumns instanceof Map && "$resourcefulRelationships" in proto && proto.$resourcefulRelationships instanceof Map && "$resourcefulComputedAccessors" in proto && proto.$resourcefulComputedAccessors instanceof Map;
+  if (typeof value === "function") {
+    return "$resourcefulName" in value && "string" === typeof value.$resourcefulName && "$resourcefulColumns" in value && value.$resourcefulColumns instanceof Map && "$resourcefulRelationships" in value && value.$resourcefulRelationships instanceof Map && "$resourcefulComputedAccessors" in value && value.$resourcefulComputedAccessors instanceof Map;
+  }
+  /* istanbul ignore if -- @preserve */
+  if ("constructor" in value) {
+    const constructor = value.constructor;
+    /* istanbul ignore if -- @preserve */
+    if (!constructor || typeof constructor !== "function") return false;
+    return isResourcefulModel(constructor);
+  }
+  /* istanbul ignore next -- @preserve */
+  if (types.isProxy(value)) {
+    const proto = Object.getPrototypeOf(value);
+    return isResourcefulModel(proto);
+  }
+  /* istanbul ignore next -- @preserve */
+  return false;
+};
+const BaseDataTypeSchemaFactory = (name, type) => {
+  return zu.object({
+    type: zu.string().allow(type).required(),
+    name: zu.string().allow(name).optional(),
+    schema: zu.object({
+      _cache: zu.required(),
+      _flags: zu.object().unknown(true).required(),
+      _ids: zu.object({
+        _byId: zu.object().instance(Map).required(),
+        _byKey: zu.object().instance(Map).required(),
+        _schemaChain: zu.boolean().required()
+      }).unknown(true).required(),
+      _invalids: zu.required(),
+      _preferences: zu.required(),
+      _refs: zu.object().unknown(true).required(),
+      _rules: zu.array().items(zu.any()).required(),
+      _singleRules: zu.object().instance(Map).required(),
+      _valids: zu.required(),
+      $: zu.required(),
+      $_root: zu.required(),
+      $_super: zu.required(),
+      $_temp: zu.required(),
+      $_terms: zu.required(),
+      ruleset: zu.func().required(),
+      type: zu.string().required()
+    }).unknown(true).optional()
+  }).unknown(true);
+};
+const getDataTypeSchemaResults = (value, name, type, schema) => {
+  if (!isObject(value)) return false;
+  if (value.type !== type) return false;
+  const base = BaseDataTypeSchemaFactory(name, type);
+  const { error: errorFromSchema } = schema.validate(
+    stripUndefinedValuesFromObject({
+      ...value,
+      type: void 0,
+      name: void 0,
+      schema: void 0
+    })
+  );
+  const { error: errorFromBase } = base.validate({
+    type: value.type,
+    name: value.name,
+    schema: value.schema
+  });
+  return "undefined" === typeof errorFromSchema && "undefined" === typeof errorFromBase;
+};
+const isResourcefulStringType = (value) => {
+  return getDataTypeSchemaResults(
+    value,
+    "ResourcefulStringType",
+    "string",
+    ResourcefulStringTypeSchema()
+  );
+};
+const isResourcefulDateType = (value) => {
+  return getDataTypeSchemaResults(
+    value,
+    "ResourcefulDateType",
+    "string",
+    ResourcefulDateTypeSchema().append({
+      format: zu.string().valid("date").required()
+    })
+  );
+};
+const isResourcefulDateTimeType = (value) => {
+  return getDataTypeSchemaResults(
+    value,
+    "ResourcefulDateTimeType",
+    "string",
+    ResourcefulDateTimeTypeSchema().append({
+      format: zu.string().valid("date-time").required()
+    })
+  );
+};
+const isResourcefulBinaryType = (value) => {
+  return getDataTypeSchemaResults(
+    value,
+    "ResourcefulBinaryType",
+    "string",
+    ResourcefulBinaryTypeSchema().append({
+      format: zu.string().valid("binary").required()
+    })
+  );
+};
+const isResourcefulNumberType = (value) => {
+  return getDataTypeSchemaResults(
+    value,
+    "ResourcefulNumberType",
+    "number",
+    ResourcefulNumberTypeSchema()
+  );
+};
+const isResourcefulIntegerType = (value) => {
+  return getDataTypeSchemaResults(
+    value,
+    "ResourcefulIntegerType",
+    "integer",
+    ResourcefulIntegerTypeSchema().append({
+      format: zu.string().valid("int32").required()
+    })
+  );
+};
+const isResourcefulBigintType = (value) => {
+  return getDataTypeSchemaResults(
+    value,
+    "ResourcefulBigintType",
+    "integer",
+    ResourcefulBigintTypeSchema().append({
+      format: zu.string().valid("int64").required()
+    })
+  );
+};
+const isResourcefulUnsignedIntegerType = (value) => {
+  return getDataTypeSchemaResults(
+    value,
+    "ResourcefulUnsignedIntegerType",
+    "integer",
+    ResourcefulUnsignedIntegerTypeSchema()
+  );
+};
+const isResourcefulBooleanType = (value) => {
+  return getDataTypeSchemaResults(
+    value,
+    "ResourcefulBooleanType",
+    "boolean",
+    ResourcefulBooleanTypeSchema()
+  );
+};
+const isResourcefulObjectType = (value) => {
+  return getDataTypeSchemaResults(
+    value,
+    "ResourcefulObjectType",
+    "object",
+    ResourcefulObjectTypeSchema()
+  );
+};
+const isResourcefulArrayType = (value) => {
+  return getDataTypeSchemaResults(
+    value,
+    "ResourcefulArrayType",
+    "array",
+    ResourcefulArrayTypeSchema()
+  );
 };
 const type_guards = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
@@ -6397,45 +6560,19 @@ const type_guards = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineP
   isLucidBinaryValue,
   isLuxonDateTime,
   isObject,
-  isResourcefulModel
+  isResourcefulArrayType,
+  isResourcefulBigintType,
+  isResourcefulBinaryType,
+  isResourcefulBooleanType,
+  isResourcefulDateTimeType,
+  isResourcefulDateType,
+  isResourcefulIntegerType,
+  isResourcefulModel,
+  isResourcefulNumberType,
+  isResourcefulObjectType,
+  isResourcefulStringType,
+  isResourcefulUnsignedIntegerType
 }, Symbol.toStringTag, { value: "Module" }));
-var CRUDOperationsEnum = /* @__PURE__ */ ((CRUDOperationsEnum2) => {
-  CRUDOperationsEnum2["CREATE"] = "create";
-  CRUDOperationsEnum2["READ"] = "read";
-  CRUDOperationsEnum2["LIST"] = "list";
-  CRUDOperationsEnum2["UPDATE"] = "update";
-  CRUDOperationsEnum2["DELETE"] = "delete";
-  return CRUDOperationsEnum2;
-})(CRUDOperationsEnum || {});
-var ACLOperationsEnum = /* @__PURE__ */ ((ACLOperationsEnum2) => {
-  ACLOperationsEnum2["WRITE"] = "write";
-  ACLOperationsEnum2["READ"] = "read";
-  return ACLOperationsEnum2;
-})(ACLOperationsEnum || {});
-const operationCRUDToACL = (operation) => {
-  if (operation === CRUDOperationsEnum.READ || operation === CRUDOperationsEnum.LIST) {
-    return ACLOperationsEnum.READ;
-  }
-  if (operation === CRUDOperationsEnum.CREATE || operation === CRUDOperationsEnum.UPDATE || operation === CRUDOperationsEnum.DELETE) {
-    return ACLOperationsEnum.WRITE;
-  }
-};
-const isString = (value) => {
-  return typeof value === "string";
-};
-const isFunction = (value) => {
-  return typeof value === "function";
-};
-const prepareFields = (fields, primaryKey) => {
-  const defaultValue = [primaryKey];
-  if (Array.isArray(fields)) {
-    return fields.length ? fields : defaultValue;
-  }
-  if (isString(fields)) {
-    return fields.length ? [fields] : defaultValue;
-  }
-  return defaultValue;
-};
 const castValueAsString = (value) => {
   if ("string" === typeof value) return value;
   if ("number" === typeof value) return value.toString();
@@ -6675,7 +6812,7 @@ function consumeString(key, value, nullable = false) {
     if (true === nullable) {
       return null;
     }
-    throw new E_INVALID_CONSUMED_VALUE([key, "String"]);
+    throw new E_INVALID_CONSUMED_VALUE([key, value, "String"]);
   }
 }
 function consumeDate(key, value, nullable = false) {
@@ -6686,7 +6823,7 @@ function consumeDate(key, value, nullable = false) {
     if (true === nullable) {
       return null;
     }
-    throw new E_INVALID_CONSUMED_VALUE([key, "Date"]);
+    throw new E_INVALID_CONSUMED_VALUE([key, value, "Date"]);
   }
 }
 function consumeDateTime(key, value, nullable = false) {
@@ -6697,7 +6834,7 @@ function consumeDateTime(key, value, nullable = false) {
     if (true === nullable) {
       return null;
     }
-    throw new E_INVALID_CONSUMED_VALUE([key, "DateTime"]);
+    throw new E_INVALID_CONSUMED_VALUE([key, value, "DateTime"]);
   }
 }
 function consumeBinary(key, value, nullable = false) {
@@ -6708,7 +6845,7 @@ function consumeBinary(key, value, nullable = false) {
     if (true === nullable) {
       return null;
     }
-    throw new E_INVALID_CONSUMED_VALUE([key, "Binary"]);
+    throw new E_INVALID_CONSUMED_VALUE([key, value, "Binary"]);
   }
 }
 function consumeNumber(key, value, nullable = false) {
@@ -6719,7 +6856,7 @@ function consumeNumber(key, value, nullable = false) {
     if (true === nullable) {
       return null;
     }
-    throw new E_INVALID_CONSUMED_VALUE([key, "Number"]);
+    throw new E_INVALID_CONSUMED_VALUE([key, value, "Number"]);
   }
 }
 function consumeInteger(key, value, nullable = false) {
@@ -6730,7 +6867,7 @@ function consumeInteger(key, value, nullable = false) {
     if (true === nullable) {
       return null;
     }
-    throw new E_INVALID_CONSUMED_VALUE([key, "Integer"]);
+    throw new E_INVALID_CONSUMED_VALUE([key, value, "Integer"]);
   }
 }
 function consumeBigint(key, value, nullable = false) {
@@ -6741,7 +6878,7 @@ function consumeBigint(key, value, nullable = false) {
     if (true === nullable) {
       return null;
     }
-    throw new E_INVALID_CONSUMED_VALUE([key, "Bigint"]);
+    throw new E_INVALID_CONSUMED_VALUE([key, value, "Bigint"]);
   }
 }
 function consumeUnsignedint(key, value, nullable = false) {
@@ -6752,7 +6889,7 @@ function consumeUnsignedint(key, value, nullable = false) {
     if (true === nullable) {
       return null;
     }
-    throw new E_INVALID_CONSUMED_VALUE([key, "Unsignedint"]);
+    throw new E_INVALID_CONSUMED_VALUE([key, value, "Unsignedint"]);
   }
 }
 function consumeBoolean(key, value, nullable = false) {
@@ -6763,13 +6900,13 @@ function consumeBoolean(key, value, nullable = false) {
     if (true === nullable) {
       return null;
     }
-    throw new E_INVALID_CONSUMED_VALUE([key, "Boolean"]);
+    throw new E_INVALID_CONSUMED_VALUE([key, value, "Boolean"]);
   }
 }
 function consumeObject(key, value, nullable = false) {
   if (value === null && nullable === true) return null;
   try {
-    if (isString(value)) {
+    if (isString$1(value)) {
       value = JSON.parse(value);
     }
     return castValueAsObject(value);
@@ -6777,7 +6914,7 @@ function consumeObject(key, value, nullable = false) {
     if (true === nullable) {
       return null;
     }
-    throw new E_INVALID_CONSUMED_VALUE([key, "Object"]);
+    throw new E_INVALID_CONSUMED_VALUE([key, value, "Object"]);
   }
 }
 function consumeArray(key, value, nullable = false) {
@@ -6788,7 +6925,7 @@ function consumeArray(key, value, nullable = false) {
     if (true === nullable) {
       return null;
     }
-    throw new E_INVALID_CONSUMED_VALUE([key, "Array"]);
+    throw new E_INVALID_CONSUMED_VALUE([key, value, "Array"]);
   }
 }
 export {
@@ -6800,15 +6937,20 @@ export {
   consumeString as F,
   consumeUnsignedint as G,
   type_guards as H,
-  isObject as I,
-  isResourcefulModel as J,
-  CRUDOperationsEnum as K,
-  operationCRUDToACL as L,
-  ACLOperationsEnum as M,
-  isFunction as N,
-  prepareFields as O,
-  isString as P,
-  DateTime as Q,
+  isResourcefulModel as I,
+  isResourcefulArrayType as J,
+  isResourcefulObjectType as K,
+  isObject as L,
+  isResourcefulBooleanType as M,
+  isResourcefulNumberType as N,
+  isResourcefulUnsignedIntegerType as O,
+  isResourcefulBigintType as P,
+  isResourcefulIntegerType as Q,
+  isResourcefulStringType as R,
+  isResourcefulBinaryType as S,
+  isResourcefulDateTimeType as T,
+  isResourcefulDateType as U,
+  DateTime as V,
   castValueAsBigint as a,
   castValueAsBinary as b,
   castValueAsArray as c,
@@ -6836,4 +6978,4 @@ export {
   consumeBinary as y,
   consumeBoolean as z
 };
-//# sourceMappingURL=decorator_utils-YSb1EGJ6.js.map
+//# sourceMappingURL=decorator_utils-gyymixlk.js.map