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

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 };

package/dist/chunk-pjv1ekwr.js

@@ -0,0 +1,284 @@
+// @bun
+import {
+  dbResolver
+} from "./chunk-441xs5k1.js";
+import {
+  CRUD_SUCCESS_KEYS
+} from "./chunk-w7h898m3.js";
+
+// source/modules/elysia/crud/operations/count.ts
+import { Elysia } from "elysia";
+
+// source/modules/elysia/crud/operations/utils/get-db-injection.ts
+var getDbInjection = (database) => typeof database === "string" ? {
+  injectStaticDB: database
+} : {
+  injectDynamicDB: database
+};
+
+// source/modules/elysia/crud/operations/count.ts
+var count = (database, tableName, {
+  hook,
+  method = "POST",
+  path = "/count"
+}) => new Elysia({
+  name: `count[${tableName}]`
+}).use(dbResolver("database:")).route(method, path, async (ctx) => {
+  const db = ctx.dynamicDB || ctx.staticDB;
+  const body = ctx.body;
+  const data = await db.getRepository(tableName).count({
+    ...body.queryOptions,
+    throwIfNoResult: true
+  });
+  return {
+    message: CRUD_SUCCESS_KEYS.COUNT_RESPONSE,
+    content: data
+  };
+}, {
+  detail: {
+    summary: "Count",
+    description: `Count ${tableName} records based on query options.`
+  },
+  ...getDbInjection(database),
+  body: `${tableName}Count`,
+  response: `${tableName}CountResponse200`,
+  ...hook
+});
+
+// source/modules/elysia/crud/operations/delete.ts
+import { Elysia as Elysia2 } from "elysia";
+var batchDelete = (database, tableName, {
+  hook,
+  method = "DELETE",
+  path = "/"
+}) => new Elysia2({
+  name: `delete[${tableName}]`
+}).use(dbResolver("database:")).route(method, path, async (ctx) => {
+  const db = ctx.dynamicDB || ctx.staticDB;
+  const body = ctx.body;
+  const selectedFields = body.queryOptions?.selectedFields ?? "*";
+  const data = await db.getRepository(tableName).delete({
+    filters: body.queryOptions.filters,
+    selectedFields,
+    throwIfNoResult: true
+  });
+  return {
+    message: CRUD_SUCCESS_KEYS.DELETE_RESPONSE,
+    content: data
+  };
+}, {
+  detail: {
+    summary: "Delete",
+    description: `Delete ${tableName} records based on query options.`
+  },
+  ...getDbInjection(database),
+  body: `${tableName}Delete`,
+  response: `${tableName}Response200`,
+  ...hook
+});
+
+// source/modules/elysia/crud/operations/deleteOne.ts
+import { Elysia as Elysia3 } from "elysia";
+var deleteOne = (database, tableName, {
+  hook,
+  method = "DELETE",
+  path = "/:id"
+}) => new Elysia3({
+  name: `deleteOne[${tableName}]`
+}).use(dbResolver("database:")).route(method, path, async (ctx) => {
+  const db = ctx.dynamicDB || ctx.staticDB;
+  const { id } = ctx.params;
+  const [primaryKey] = db.getTable(tableName).primaryKey;
+  const data = await db.getRepository(tableName).delete({
+    selectedFields: "*",
+    filters: {
+      [primaryKey]: id
+    },
+    throwIfNoResult: {
+      httpStatusCode: "NOT_FOUND",
+      message: `Record with id ${id} not found in ${tableName}`
+    }
+  });
+  return {
+    message: CRUD_SUCCESS_KEYS.DELETE_ONE_RESPONSE,
+    content: data
+  };
+}, {
+  detail: {
+    summary: "Delete One",
+    description: `Delete a single ${tableName} record by its primary key.`
+  },
+  ...getDbInjection(database),
+  params: `${tableName}IdParam`,
+  response: `${tableName}Response200`,
+  ...hook
+});
+
+// source/modules/elysia/crud/operations/find.ts
+import { Elysia as Elysia4 } from "elysia";
+var find = (database, tableName, {
+  hook,
+  method = "POST",
+  path = "/find"
+}) => new Elysia4({
+  name: `find[${tableName}]`
+}).use(dbResolver("database:")).route(method, path, async (ctx) => {
+  const db = ctx.dynamicDB || ctx.staticDB;
+  const body = ctx.body;
+  const data = await db.getRepository(tableName).find({
+    ...body?.queryOptions || {},
+    throwIfNoResult: false
+  });
+  return {
+    message: CRUD_SUCCESS_KEYS.FIND_RESPONSE,
+    content: data
+  };
+}, {
+  detail: {
+    summary: "Find",
+    description: `Find ${tableName} records based on query options.`
+  },
+  ...getDbInjection(database),
+  body: `${tableName}Find`,
+  response: `${tableName}Response200`,
+  ...hook
+});
+
+// source/modules/elysia/crud/operations/findOne.ts
+import { Elysia as Elysia5 } from "elysia";
+var findOne = (database, tableName, {
+  hook,
+  method = "GET",
+  path = "/:id"
+}) => new Elysia5({
+  name: `findOne[${tableName}]`
+}).use(dbResolver("database:")).route(method, path, async (ctx) => {
+  const db = ctx.dynamicDB || ctx.staticDB;
+  const { id } = ctx.params;
+  const [primaryKey] = db.getTable(tableName).primaryKey;
+  const data = await db.getRepository(tableName).find({
+    filters: {
+      [primaryKey]: id
+    },
+    throwIfNoResult: {
+      httpStatusCode: "NOT_FOUND",
+      message: `Record with id ${id} not found in ${tableName}`
+    }
+  });
+  return {
+    message: CRUD_SUCCESS_KEYS.FIND_ONE_RESPONSE,
+    content: data
+  };
+}, {
+  detail: {
+    summary: "Find One",
+    description: `Find a single ${tableName} record by its primary key.`
+  },
+  ...getDbInjection(database),
+  params: `${tableName}IdParam`,
+  response: `${tableName}Response200`,
+  ...hook
+});
+
+// source/modules/elysia/crud/operations/insert.ts
+import { Elysia as Elysia6 } from "elysia";
+var insert = (database, tableName, {
+  hook,
+  method = "POST",
+  path = "/"
+}) => new Elysia6({
+  name: `insert[${tableName}]`
+}).use(dbResolver("database:")).route(method, path, async (ctx) => {
+  const db = ctx.dynamicDB || ctx.staticDB;
+  const body = ctx.body;
+  const selectedFields = body.queryOptions?.selectedFields ?? "*";
+  const data = await db.getRepository(tableName).insert(body.data, {
+    selectedFields,
+    throwIfNoResult: true
+  });
+  return {
+    message: CRUD_SUCCESS_KEYS.INSERT_RESPONSE,
+    content: data
+  };
+}, {
+  detail: {
+    summary: "Insert",
+    description: `Insert one or more records into the ${tableName} table.`
+  },
+  ...getDbInjection(database),
+  body: `${tableName}Insert`,
+  response: `${tableName}Response200`,
+  ...hook
+});
+
+// source/modules/elysia/crud/operations/update.ts
+import { Elysia as Elysia7 } from "elysia";
+var update = (database, tableName, {
+  hook,
+  method = "PATCH",
+  path = "/"
+}) => new Elysia7({
+  name: `update[${tableName}]`
+}).use(dbResolver("database:")).route(method, path, async (ctx) => {
+  const db = ctx.dynamicDB || ctx.staticDB;
+  const body = ctx.body;
+  const data = await db.getRepository(tableName).update(body.data, {
+    filters: body.queryOptions.filters,
+    selectedFields: body.queryOptions.selectedFields ?? "*",
+    throwIfNoResult: true
+  });
+  return {
+    message: CRUD_SUCCESS_KEYS.UPDATE_RESPONSE,
+    content: data
+  };
+}, {
+  detail: {
+    summary: "Update",
+    description: `Update one or more ${tableName} records based on query options.`
+  },
+  ...getDbInjection(database),
+  body: `${tableName}Update`,
+  response: `${tableName}Response200`,
+  ...hook
+});
+
+// source/modules/elysia/crud/operations/updateOne.ts
+import { Elysia as Elysia8 } from "elysia";
+var updateOne = (database, tableName, {
+  hook,
+  method = "PATCH",
+  path = "/:id"
+}) => new Elysia8({
+  name: `updateOne[${tableName}]`
+}).use(dbResolver("database:")).route(method, path, async (ctx) => {
+  const db = ctx.dynamicDB || ctx.staticDB;
+  const { id } = ctx.params;
+  const body = ctx.body;
+  const [primaryKey] = db.getTable(tableName).primaryKey;
+  const data = await db.getRepository(tableName).update(body.data, {
+    selectedFields: "*",
+    filters: {
+      [primaryKey]: id
+    },
+    throwIfNoResult: {
+      httpStatusCode: "NOT_FOUND",
+      message: `Record with id ${id} not found in ${tableName}`
+    }
+  });
+  return {
+    message: CRUD_SUCCESS_KEYS.UPDATE_ONE_RESPONSE,
+    content: data
+  };
+}, {
+  detail: {
+    summary: "Update Single Record",
+    description: `Update a single record in the ${tableName} table by its primary key.`
+  },
+  ...getDbInjection(database),
+  params: `${tableName}IdParam`,
+  body: `${tableName}UpdateOne`,
+  response: `${tableName}Response200`,
+  ...hook
+});
+
+export { count, batchDelete, deleteOne, find, findOne, insert, update, updateOne };

package/dist/chunk-rz5p4j3p.js

@@ -0,0 +1,13 @@
+// @bun
+// source/modules/logger/enums/logger-error-keys.ts
+var LOGGER_ERROR_KEYS = {
+  BEFORE_EXIT_CLOSE_ERROR: "mrx-core.logger.error.before_exit_close_error",
+  BEFORE_EXIT_FLUSH_ERROR: "mrx-core.logger.error.before_exit_flush_error",
+  NO_SINKS_PROVIDED: "mrx-core.logger.error.no_sinks_provided",
+  REGISTER_SINK_ERROR: "mrx-core.logger.error.register_sink_error",
+  SINK_ALREADY_ADDED: "mrx-core.logger.error.sink_already_added",
+  SINK_CLOSE_ERROR: "mrx-core.logger.error.sink_close_error",
+  SINK_LOG_ERROR: "mrx-core.logger.error.sink_log_error"
+};
+
+export { LOGGER_ERROR_KEYS };

package/dist/chunk-spnh9dzk.js

@@ -0,0 +1,10 @@
+// @bun
+// source/modules/elysia/error/enums/error.keys.ts
+var ERROR_KEYS = {
+  CORE_ERROR_VALIDATION: "mrx-core.error.validation",
+  CORE_ERROR_NOT_FOUND: "mrx-core.error.not_found",
+  CORE_ERROR_PARSE: "mrx-core.error.parse",
+  CORE_ERROR_INTERNAL_SERVER_ERROR: "mrx-core.error.internal_server_error"
+};
+
+export { ERROR_KEYS };