@mrxsys/mrx-core 2.11.0-2-and-276-20251029 → 2.11.0-2-and-279-20251103

package/dist/chunk-grfyngq0.js

@@ -0,0 +1,39 @@
+// @bun
+// source/shared/utils/is-date-string.ts
+var isDateString = (v) => typeof v === "string" && new Date(v).toString() !== "Invalid Date";
+
+// source/shared/utils/stream.ts
+var makeStreamAsyncIterable = (stream) => {
+  const asyncIterable = {
+    [Symbol.asyncIterator]: () => ({
+      next() {
+        return new Promise((resolve, reject) => {
+          const cleanup = () => {
+            stream.off("data", onData);
+            stream.off("end", onEnd);
+            stream.off("error", onError);
+          };
+          const onData = (data) => {
+            cleanup();
+            resolve({ value: data, done: false });
+          };
+          const onEnd = () => {
+            cleanup();
+            resolve({ value: undefined, done: true });
+          };
+          const onError = (error) => {
+            cleanup();
+            reject(error);
+          };
+          stream.on("data", onData);
+          stream.on("end", onEnd);
+          stream.on("error", onError);
+        });
+      }
+    })
+  };
+  stream[Symbol.asyncIterator] = asyncIterable[Symbol.asyncIterator];
+  return stream;
+};
+
+export { isDateString, makeStreamAsyncIterable };

package/dist/chunk-gtn1kn0z.js

@@ -0,0 +1,79 @@
+// @bun
+import {
+  DATA_ERROR_KEYS
+} from "./chunk-jksb9ers.js";
+import {
+  BaseError
+} from "./chunk-9cgzhc50.js";
+
+// source/modules/data/data.ts
+var _validateDataNull = (data) => {
+  if (data === null || data === undefined)
+    throw new BaseError(DATA_ERROR_KEYS.DATA_IS_NULL);
+};
+var filterByKeyExclusion = (data, keys, excludeNullUndefined) => {
+  _validateDataNull(data);
+  const filteredData = {};
+  for (const key in data) {
+    const typedKey = key;
+    if (!keys.includes(typedKey) && (!excludeNullUndefined || data[typedKey] !== null && data[typedKey] !== undefined))
+      filteredData[key] = data[typedKey];
+  }
+  return filteredData;
+};
+var filterByKeyExclusionRecursive = (data, keys, excludeNullUndefined = false) => {
+  _validateDataNull(data);
+  const filteredData = {};
+  for (const key in data) {
+    const typedKey = key;
+    if (!keys.includes(typedKey) && (!excludeNullUndefined || data[typedKey] !== null && data[typedKey] !== undefined))
+      if (typeof data[typedKey] === "object" && data[typedKey] !== null && !Array.isArray(data[typedKey]))
+        filteredData[key] = filterByKeyExclusionRecursive(data[typedKey], keys, excludeNullUndefined);
+      else if (Array.isArray(data[typedKey]))
+        filteredData[key] = data[typedKey].map((item) => {
+          if (typeof item === "object" && item !== null && !Array.isArray(item))
+            return filterByKeyExclusionRecursive(item, keys, excludeNullUndefined);
+          return item;
+        });
+      else
+        filteredData[key] = data[typedKey];
+  }
+  for (const symbol of Object.getOwnPropertySymbols(data))
+    filteredData[symbol] = data[symbol];
+  return filteredData;
+};
+var filterByKeyInclusion = (data, keys, excludeNullUndefined, throwIfDataIsNull = true) => {
+  if (throwIfDataIsNull)
+    _validateDataNull(data);
+  const filteredData = {};
+  for (const key of keys) {
+    const typedKey = key;
+    if (typedKey in data && (!excludeNullUndefined || data[typedKey] !== null && data[typedKey] !== undefined))
+      filteredData[key] = data[typedKey];
+  }
+  return filteredData;
+};
+var filterByValue = (data, predicate, excludeNullUndefined = false, throwIfDataIsNull = true) => {
+  if (throwIfDataIsNull)
+    _validateDataNull(data);
+  const filteredData = {};
+  for (const key in data)
+    if (Object.hasOwn(data, key)) {
+      const typedKey = key;
+      if (predicate(data[typedKey]) && (!excludeNullUndefined || data[typedKey] !== null && data[typedKey] !== undefined))
+        filteredData[typedKey] = data[typedKey];
+    }
+  return filteredData;
+};
+var transformKeys = (data, transformer, throwIfDataIsNull = true) => {
+  if (throwIfDataIsNull)
+    _validateDataNull(data);
+  const result = {};
+  for (const key in data) {
+    const transformedKey = transformer.convertCase(key);
+    result[transformedKey] = data[key];
+  }
+  return result;
+};
+
+export { filterByKeyExclusion, filterByKeyExclusionRecursive, filterByKeyInclusion, filterByValue, transformKeys };

package/dist/chunk-jksb9ers.js

@@ -0,0 +1,7 @@
+// @bun
+// source/modules/data/enums/data-error-keys.ts
+var DATA_ERROR_KEYS = {
+  DATA_IS_NULL: "mrx-core.data.error.is_null"
+};
+
+export { DATA_ERROR_KEYS };

package/dist/chunk-m3grz32t.js

@@ -0,0 +1,27 @@
+// @bun
+// source/modules/totp/utils/create-counter-buffer.ts
+var createCounterBuffer = (counter) => {
+  const counterBuffer = new ArrayBuffer(8);
+  const counterView = new DataView(counterBuffer);
+  if (typeof counter === "bigint")
+    counterView.setBigUint64(0, counter, false);
+  else
+    counterView.setUint32(4, counter, false);
+  return counterBuffer;
+};
+
+// source/modules/totp/utils/dynamic-truncation.ts
+var dynamicTruncation = (hmacArray, digits) => {
+  const offset = hmacArray[hmacArray.length - 1] & 15;
+  const code = ((hmacArray[offset] & 127) << 24 | (hmacArray[offset + 1] & 255) << 16 | (hmacArray[offset + 2] & 255) << 8 | hmacArray[offset + 3] & 255) % 10 ** digits;
+  return code.toString().padStart(digits, "0");
+};
+
+// source/modules/totp/utils/generate-hmac.ts
+import { webcrypto } from "crypto";
+var generateHmac = async (key, data) => {
+  const hmac = await webcrypto.subtle.sign("HMAC", key, data);
+  return new Uint8Array(hmac);
+};
+
+export { createCounterBuffer, dynamicTruncation, generateHmac };

package/dist/chunk-mvrxngm7.js

@@ -0,0 +1,41 @@
+// @bun
+// source/modules/typed-event-emitter/typed-event-emitter.ts
+import { EventEmitter } from "events";
+
+class TypedEventEmitter extends EventEmitter {
+  emit(event, ...args) {
+    return super.emit(event, ...args);
+  }
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  once(event, listener) {
+    return super.once(event, listener);
+  }
+  addListener(event, listener) {
+    return super.addListener(event, listener);
+  }
+  removeListener(event, listener) {
+    return super.removeListener(event, listener);
+  }
+  off(event, listener) {
+    return super.off(event, listener);
+  }
+  listenerCount(event) {
+    return super.listenerCount(event);
+  }
+  listeners(event) {
+    return super.listeners(event);
+  }
+  rawListeners(event) {
+    return super.rawListeners(event);
+  }
+  prependListener(event, listener) {
+    return super.prependListener(event, listener);
+  }
+  prependOnceListener(event, listener) {
+    return super.prependOnceListener(event, listener);
+  }
+}
+
+export { TypedEventEmitter };

package/dist/chunk-n0n14mf8.js

@@ -0,0 +1,7 @@
+// @bun
+// source/shared/enums/utils-error-keys.ts
+var UTILS_ERROR_KEYS = {
+  INVALID_ENVIRONMENT: "mrx-core.utils.error.invalid_environment"
+};
+
+export { UTILS_ERROR_KEYS };

package/dist/chunk-p14h6jfs.js

@@ -0,0 +1,365 @@
+// @bun
+import {
+  flatten
+} from "./chunk-9dzsj7f2.js";
+import {
+  filterByKeyExclusionRecursive
+} from "./chunk-gtn1kn0z.js";
+
+// source/modules/elysia/crud/utils/create-count-response-200-schema.ts
+import { t } from "elysia";
+var createCountResponse200Schema = () => t.Object({
+  message: t.String(),
+  content: t.Number()
+});
+
+// source/modules/elysia/crud/utils/is-date-from-elysia-typebox.ts
+import { KindGuard } from "@sinclair/typebox";
+var isDateFromElysiaTypeBox = (schema) => KindGuard.IsUnion(schema) && schema.anyOf.length === 4 && schema.anyOf.some((item) => KindGuard.IsDate(item)) && schema.anyOf.some((item) => KindGuard.IsString(item) && item.format === "date-time") && schema.anyOf.some((item) => KindGuard.IsString(item) && item.format === "date") && schema.anyOf.some((item) => KindGuard.IsNumber(item));
+
+// source/modules/elysia/crud/utils/create-adaptive-where-clause-schema.ts
+import { KindGuard as KindGuard2 } from "@sinclair/typebox/type";
+import { t as t2 } from "elysia";
+var createAdaptiveWhereClauseSchema = (schema) => {
+  const common = {
+    $eq: schema,
+    $neq: schema,
+    $isNull: t2.Boolean()
+  };
+  const strNumDate = KindGuard2.IsString(schema) || KindGuard2.IsNumber(schema) || isDateFromElysiaTypeBox(schema) ? {
+    $in: t2.Array(schema, { minItems: 1, uniqueItems: true }),
+    $nin: t2.Array(schema, { minItems: 1, uniqueItems: true }),
+    $like: t2.String(),
+    $nlike: t2.String()
+  } : {};
+  const numDate = KindGuard2.IsNumber(schema) || isDateFromElysiaTypeBox(schema) ? {
+    $lt: schema,
+    $lte: schema,
+    $gt: schema,
+    $gte: schema,
+    $between: t2.Tuple([schema, schema]),
+    $nbetween: t2.Tuple([schema, schema])
+  } : {};
+  return t2.Partial(t2.Object({ ...common, ...strNumDate, ...numDate }));
+};
+
+// source/modules/elysia/crud/utils/create-properties-schema.ts
+import { t as t3 } from "elysia";
+var createPropertiesSchema = (schema) => {
+  const { properties } = schema;
+  const clauseSchema = {};
+  for (const [key, propertySchema] of Object.entries(properties))
+    clauseSchema[key] = flatten(t3.Union([
+      createAdaptiveWhereClauseSchema(propertySchema),
+      propertySchema
+    ]));
+  return t3.Object(clauseSchema);
+};
+
+// source/modules/elysia/crud/utils/create-q-schema.ts
+import { t as t4 } from "elysia/type-system";
+var createQSchema = (schema) => t4.Union([
+  t4.Object({
+    selectedFields: t4.Union([
+      t4.KeyOf(schema),
+      t4.Array(t4.KeyOf(schema), {
+        minItems: 1,
+        uniqueItems: true
+      })
+    ]),
+    value: t4.Union([
+      t4.Number(),
+      t4.String()
+    ])
+  }),
+  t4.Number(),
+  t4.String()
+]);
+
+// source/modules/elysia/crud/utils/create-filters-schema.ts
+import { t as t5 } from "elysia";
+var createFiltersSchema = (schema) => t5.Composite([
+  t5.Object({
+    $q: createQSchema(schema)
+  }),
+  createPropertiesSchema(schema)
+], {
+  minProperties: 1
+});
+
+// source/modules/elysia/crud/utils/create-count-schema.ts
+import { t as t6 } from "elysia";
+var createCountSchema = (schema) => {
+  const sanitizedSchema = filterByKeyExclusionRecursive(schema, [
+    "minLength",
+    "maxLength",
+    "pattern",
+    "minimum",
+    "maximum",
+    "exclusiveMinimum",
+    "exclusiveMaximum",
+    "multipleOf",
+    "minItems",
+    "maxItems",
+    "maxContains",
+    "minContains",
+    "minProperties",
+    "maxProperties",
+    "uniqueItems",
+    "minimumTimestamp",
+    "maximumTimestamp",
+    "exclusiveMinimumTimestamp",
+    "exclusiveMaximumTimestamp",
+    "multipleOfTimestamp",
+    "required",
+    "examples",
+    "example",
+    "default",
+    "title",
+    "description"
+  ]);
+  return t6.Partial(t6.Object({
+    queryOptions: t6.Partial(t6.Object({
+      filters: t6.Union([
+        t6.Partial(createFiltersSchema(sanitizedSchema)),
+        t6.Array(t6.Partial(createFiltersSchema(sanitizedSchema)))
+      ])
+    }))
+  }));
+};
+
+// source/modules/elysia/crud/utils/create-selected-fields-schema.ts
+import { t as t7 } from "elysia/type-system";
+var createSelectedFieldsSchema = (schema) => t7.Union([
+  t7.KeyOf(schema),
+  t7.Literal("*"),
+  t7.Array(t7.KeyOf(schema), {
+    minItems: 1,
+    uniqueItems: true
+  })
+]);
+
+// source/modules/elysia/crud/utils/create-delete-schema.ts
+import { t as t8 } from "elysia";
+var createDeleteSchema = (schema) => {
+  const sanitizedSchema = filterByKeyExclusionRecursive(schema, [
+    "minLength",
+    "maxLength",
+    "pattern",
+    "minimum",
+    "maximum",
+    "exclusiveMinimum",
+    "exclusiveMaximum",
+    "multipleOf",
+    "minItems",
+    "maxItems",
+    "maxContains",
+    "minContains",
+    "minProperties",
+    "maxProperties",
+    "uniqueItems",
+    "minimumTimestamp",
+    "maximumTimestamp",
+    "exclusiveMinimumTimestamp",
+    "exclusiveMaximumTimestamp",
+    "multipleOfTimestamp",
+    "required",
+    "examples",
+    "example",
+    "default",
+    "title",
+    "description"
+  ]);
+  return t8.Object({
+    queryOptions: t8.Object({
+      selectedFields: t8.Optional(createSelectedFieldsSchema(sanitizedSchema)),
+      filters: t8.Union([
+        t8.Partial(createFiltersSchema(sanitizedSchema)),
+        t8.Array(t8.Partial(createFiltersSchema(sanitizedSchema)), { minItems: 1 })
+      ])
+    })
+  });
+};
+
+// source/modules/elysia/crud/utils/create-order-schema.ts
+import { t as t9 } from "elysia/type-system";
+var createOrderSchema = (schema) => t9.Union([
+  t9.Object({
+    selectedField: t9.KeyOf(schema),
+    direction: t9.Union([t9.Literal("asc"), t9.Literal("desc")])
+  }),
+  t9.Array(t9.Object({
+    selectedField: t9.KeyOf(schema),
+    direction: t9.Union([t9.Literal("asc"), t9.Literal("desc")])
+  }), {
+    minItems: 1,
+    uniqueItems: true
+  })
+]);
+
+// source/modules/elysia/crud/utils/create-find-schema.ts
+import { t as t10 } from "elysia";
+var createFindSchema = (schema) => {
+  const sanitizedSchema = filterByKeyExclusionRecursive(schema, [
+    "minLength",
+    "maxLength",
+    "pattern",
+    "minimum",
+    "maximum",
+    "exclusiveMinimum",
+    "exclusiveMaximum",
+    "multipleOf",
+    "minItems",
+    "maxItems",
+    "maxContains",
+    "minContains",
+    "minProperties",
+    "maxProperties",
+    "uniqueItems",
+    "minimumTimestamp",
+    "maximumTimestamp",
+    "exclusiveMinimumTimestamp",
+    "exclusiveMaximumTimestamp",
+    "multipleOfTimestamp",
+    "required",
+    "examples",
+    "example",
+    "default",
+    "title",
+    "description"
+  ]);
+  return t10.Partial(t10.Object({
+    queryOptions: t10.Partial(t10.Object({
+      selectedFields: createSelectedFieldsSchema(sanitizedSchema),
+      orderBy: createOrderSchema(sanitizedSchema),
+      filters: t10.Union([
+        t10.Partial(createFiltersSchema(sanitizedSchema)),
+        t10.Array(t10.Partial(createFiltersSchema(sanitizedSchema)))
+      ]),
+      limit: t10.Number({
+        default: 100,
+        minimum: 1
+      }),
+      offset: t10.Number({
+        default: 0,
+        minimum: 0
+      })
+    }))
+  }));
+};
+
+// source/modules/elysia/crud/utils/create-id-param-schema.ts
+import { t as t11 } from "elysia";
+var createIdParamSchema = () => t11.Object({
+  id: t11.Union([
+    t11.String(),
+    t11.Number({
+      minimum: 1,
+      maximum: Number.MAX_SAFE_INTEGER
+    })
+  ])
+});
+
+// source/modules/elysia/crud/utils/create-insert-schema.ts
+import { t as t12 } from "elysia";
+var createInsertSchema = (schema) => t12.Object({
+  queryOptions: t12.Optional(t12.Object({
+    selectedFields: createSelectedFieldsSchema(schema)
+  })),
+  data: t12.Union([
+    schema,
+    t12.Array(schema, {
+      minItems: 1,
+      uniqueItems: true
+    })
+  ])
+});
+
+// source/modules/elysia/crud/utils/create-response-200-schema.ts
+import { t as t13 } from "elysia";
+var createResponse200Schema = (schema) => {
+  const sanitizedSchema = filterByKeyExclusionRecursive(schema, [
+    "minLength",
+    "maxLength",
+    "pattern",
+    "minimum",
+    "maximum",
+    "exclusiveMinimum",
+    "exclusiveMaximum",
+    "multipleOf",
+    "minItems",
+    "maxItems",
+    "maxContains",
+    "minContains",
+    "minProperties",
+    "maxProperties",
+    "uniqueItems",
+    "minimumTimestamp",
+    "maximumTimestamp",
+    "exclusiveMinimumTimestamp",
+    "exclusiveMaximumTimestamp",
+    "multipleOfTimestamp",
+    "required",
+    "default"
+  ]);
+  const { properties } = sanitizedSchema;
+  const responseSchema = {};
+  for (const key in properties)
+    responseSchema[key] = flatten(t13.Union([properties[key], t13.Null()]));
+  return t13.Object({
+    message: t13.String(),
+    content: t13.Array(t13.Partial(t13.Object(responseSchema)))
+  });
+};
+
+// source/modules/elysia/crud/utils/create-update-one-schema.ts
+import { t as t14 } from "elysia";
+var createUpdateOneSchema = (schema) => t14.Object({
+  data: t14.Partial(schema)
+});
+
+// source/modules/elysia/crud/utils/create-update-schema.ts
+import { t as t15 } from "elysia";
+var createUpdateSchema = (schema) => {
+  const sanitizedSchema = filterByKeyExclusionRecursive(schema, [
+    "minLength",
+    "maxLength",
+    "pattern",
+    "minimum",
+    "maximum",
+    "exclusiveMinimum",
+    "exclusiveMaximum",
+    "multipleOf",
+    "minItems",
+    "maxItems",
+    "maxContains",
+    "minContains",
+    "minProperties",
+    "maxProperties",
+    "uniqueItems",
+    "minimumTimestamp",
+    "maximumTimestamp",
+    "exclusiveMinimumTimestamp",
+    "exclusiveMaximumTimestamp",
+    "multipleOfTimestamp",
+    "required",
+    "examples",
+    "example",
+    "default",
+    "title",
+    "description"
+  ]);
+  schema.minProperties = 1;
+  return t15.Object({
+    queryOptions: t15.Object({
+      selectedFields: t15.Optional(createSelectedFieldsSchema(sanitizedSchema)),
+      filters: t15.Union([
+        t15.Partial(createFiltersSchema(sanitizedSchema)),
+        t15.Array(t15.Partial(createFiltersSchema(sanitizedSchema)), { minItems: 1 })
+      ])
+    }),
+    data: t15.Partial(schema)
+  });
+};
+
+export { createCountResponse200Schema, isDateFromElysiaTypeBox, createAdaptiveWhereClauseSchema, createPropertiesSchema, createQSchema, createFiltersSchema, createCountSchema, createSelectedFieldsSchema, createDeleteSchema, createOrderSchema, createFindSchema, createIdParamSchema, createInsertSchema, createResponse200Schema, createUpdateOneSchema, createUpdateSchema };