@mrxsys/mrx-core 2.11.0 → 2.12.0-1-and-288-20251203

package/dist/chunk-4g0x6g4j.js

@@ -1,365 +0,0 @@
-// @bun
-import {
-  flatten
-} from "./chunk-9dzsj7f2.js";
-import {
-  filterByKeyExclusionRecursive
-} from "./chunk-hv6g22kf.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.Required(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-9dzsj7f2.js

@@ -1,23 +0,0 @@
-// @bun
-// source/shared/utils/flatten.ts
-import { KindGuard } from "@sinclair/typebox";
-import { t } from "elysia";
-var _flattenInto = (type, result) => {
-  if (KindGuard.IsUnion(type))
-    for (const subType of type.anyOf)
-      _flattenInto(subType, result);
-  else
-    result.push(type);
-};
-var flatten = (type) => {
-  if (!KindGuard.IsUnion(type))
-    return type;
-  const isAlreadyFlat = type.anyOf.every((subType) => !KindGuard.IsUnion(subType));
-  if (isAlreadyFlat)
-    return type;
-  const result = [];
-  _flattenInto(type, result);
-  return t.Union(result);
-};
-
-export { flatten };

package/dist/chunk-tmvj28bq.js

@@ -1,284 +0,0 @@
-// @bun
-import {
-  dbResolver
-} from "./chunk-yzgdqb02.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-w7h898m3.js

@@ -1,14 +0,0 @@
-// @bun
-// source/modules/elysia/crud/enums/crud-success-keys.ts
-var CRUD_SUCCESS_KEYS = {
-  COUNT_RESPONSE: "mrx-core.crud.success.count_response",
-  DELETE_RESPONSE: "mrx-core.crud.success.delete_response",
-  DELETE_ONE_RESPONSE: "mrx-core.crud.success.delete_one_response",
-  FIND_RESPONSE: "mrx-core.crud.success.find_response",
-  FIND_ONE_RESPONSE: "mrx-core.crud.success.find_one_response",
-  INSERT_RESPONSE: "mrx-core.crud.success.insert_response",
-  UPDATE_RESPONSE: "mrx-core.crud.success.update_response",
-  UPDATE_ONE_RESPONSE: "mrx-core.crud.success.update_one_response"
-};
-
-export { CRUD_SUCCESS_KEYS };