@mrxsys/mrx-core 2.4.0 → 2.5.0

package/dist/modules/database/index.js

@@ -0,0 +1,14 @@
+// @bun
+import {
+  MSSQL,
+  Table
+} from "../../chunk-pc66jgqv.js";
+import"../../chunk-1a3wj3m1.js";
+import"../../chunk-5qtpggzv.js";
+import"../../chunk-yvyahr2h.js";
+import"../../chunk-84mqvfsk.js";
+import"../../chunk-vknq69e0.js";
+export {
+  Table,
+  MSSQL
+};

package/dist/{database → modules/database}/mssql.d.ts

@@ -1,19 +1,19 @@
 import { type Knex } from 'knex';
-import { Repository } from '../repository/repository';
-import { TypedEventEmitter } from '../typedEventEmitter/typedEventEmitter';
+import { Repository } from '../../modules/repository/repository';
+import { TypedEventEmitter } from '../../modules/typedEventEmitter/typedEventEmitter';
 import type { MssqlEventMap } from './events/mssqlEventMap';
 import { Table } from './table';
 import type { MSSQLDatabaseOptions } from './types/mssqlDatabaseOption';
 /**
  * Manages the connection with an MSSQL database.
- * The class extends {@link EventEmitter}.
+ * The class extends {@link TypedEventEmitter}<{@link MssqlEventMap}>.
  *
- * - Emits events for logging and table operations.
+ * - Emits events.
  * - Automatically generates repositories and tables for CRUD operations.
  * - Allows custom repository implementations per table.
  *
- * Example usage:
- * ```typescript
+ * @example
+ * ```ts
  * const mssql = new MSSQL(options);
  * await mssql.connect();
  * const users = await mssql.getRepository('users').find();
@@ -30,29 +30,25 @@ export declare class MSSQL extends TypedEventEmitter<MssqlEventMap> {
     private readonly _databaseName;
     /**
      * A map of tables in the database.
-     * @see {@link Table}
      */
     private readonly _tables;
     /**
      * A map of repositories for each table.
-     * @see {@link Repository}
      */
     private readonly _repositories;
     /**
      * The Knex instance for the database connection.
-     * @see {@link Knex}
-     * @see https://knexjs.org/
      */
     private readonly _db;
     /**
      * Indicates whether to add basic event listeners for all tables.
-     * @default false
+     * @defaultValue false
      */
     private readonly _isEventEnabled;
     /**
      * Create a new instance of `MSSQL` with the specified options.
+     *
      * @param options - The configuration options for the MSSQL database connection.
-     * @see {@link MSSQLDatabaseOptions}
      */
     constructor(options: MSSQLDatabaseOptions);
     /**
@@ -61,27 +57,27 @@ export declare class MSSQL extends TypedEventEmitter<MssqlEventMap> {
      * If the connection is successful, introspection is performed to retrieve information about tables, columns(fields), and primary keys.
      * This information is used to create instances of {@link Table} and {@link Repository} for each table in the database.
      *
-     * @throws ({@link CoreError}) Thrown if an error occurs during the connection process. ({@link databaseErrorKeys.mssqlConnectionError})
+     * @throws ({@link BaseError}) Thrown if an error occurs during the connection process.
      */
     connect(): Promise<void>;
     /**
      * Closes the connection to the MSSQL database.
      *
-     * @throws ({@link CoreError}) Thrown if the database is not connected. ({@link databaseErrorKeys.mssqlNotConnected})
-     * @throws ({@link CoreError}) Thrown if an error occurs during the disconnection process. ({@link databaseErrorKeys.mssqlDisconnectError})
+     * @throws ({@link BaseError}) Thrown if the database is not connected.
+     * @throws ({@link BaseError}) Thrown if an error occurs during the disconnection process.
      */
     disconnect(): Promise<void>;
     /**
      * Retrieves a repository for a specific table.
      *
-     * @param tableName - The name of the table to retrieve the repository for.
-     * @param customRepository - Optional custom repository class to use for the table. The class must extend {@link Repository}.
+     * @template TModel - The type of the model for the repository.
+     * @template TRepo - The repository to retrieve.
      *
-     * @throws ({@link CoreError}) Thrown if the database is not connected. ({@link databaseErrorKeys.mssqlNotConnected})
-     * @throws ({@link CoreError}) Thrown if the specified table is not found. ({@link databaseErrorKeys.mssqlTableNotFound})
+     * @param tableName - The name of the table to retrieve the repository for.
+     * @param customRepository - Optional custom repository class to use for the table.
      *
-     * @template TModel - The type of the model for the repository.
-     * @template TRepo - The repository to retrieve extends {@link Repository}.
+     * @throws ({@link BaseError}) Thrown if the database is not connected.
+     * @throws ({@link BaseError}) Thrown if the specified table is not found.
      *
      * @returns The {@link Repository} for the specified table.
      */
@@ -92,11 +88,11 @@ export declare class MSSQL extends TypedEventEmitter<MssqlEventMap> {
      *
      * @param tableName - The name of the table to retrieve.
      *
-     * @throws ({@link CoreError}) Thrown if the database is not connected. ({@link databaseErrorKeys.mssqlNotConnected})
-     * @throws ({@link CoreError}) Thrown if the specified table is not found. ({@link databaseErrorKeys.mssqlTableNotFound})
+     * @throws ({@link BaseError}) Thrown if the database is not connected.
+     * @throws ({@link BaseError}) Thrown if the specified table is not found.
      *
      * @returns The {@link Table} object for the specified table.
-    */
+     */
     getTable(tableName: string): Table;
     /**
      * Retrieves the name of the database.
@@ -125,7 +121,7 @@ export declare class MSSQL extends TypedEventEmitter<MssqlEventMap> {
     /**
      * Retrieves the Knex instance for the database connection.
      *
-     * @throws ({@link CoreError}) Thrown if the database is not connected. ({@link databaseErrorKeys.mssqlNotConnected})
+     * @throws ({@link BaseError}) Thrown if the database is not connected.
      *
      * @returns The {@link Knex} instance for the database connection.
      */

package/dist/{database → modules/database}/table.d.ts

@@ -1,15 +1,15 @@
-import type { TableEventMap } from '../database/events/tableEventMap';
-import { TypedEventEmitter } from '../typedEventEmitter/typedEventEmitter';
+import type { TableEventMap } from '../../modules/database/events/tableEventMap';
+import { TypedEventEmitter } from '../../modules/typedEventEmitter/typedEventEmitter';
 /**
  * Represents a database table and provides access to its metadata (name, fields, primary key).
+ * The class extends `TypedEventEmitter`<{@link TableEventMap}> to allow for event-driven programming.
  *
- * - Emits events for table operations (e.g., SELECTED, CREATED, UPDATED, DELETED).
- * - Used for query construction and event handling in the database layer.
+ * Can emit events for table operations (e.g., SELECTED, CREATED, UPDATED, DELETED). when is attach to {@link MSSQL} class.
  *
  * Example:
- * ```typescript
+ * ```ts
  * const table = new Table('db', 'users', ['id', 'name'], ['id', 'NUMBER']);
- * table.on('SELECTED', data => console.log(data));
+ * table.on('selected', data => console.log(data));
  * ```
  */
 export declare class Table extends TypedEventEmitter<TableEventMap> {

package/dist/modules/database/types/index.d.ts

@@ -0,0 +1,3 @@
+export type { MSSQLDatabaseOptions } from './mssqlDatabaseOption';
+export type { MssqlEventLog } from './mssqlEventLog';
+export type { QueryContext } from './queryContext';

package/dist/{database → modules/database}/types/mssqlDatabaseOption.d.ts

@@ -1,41 +1,24 @@
 /**
  * Options to configure the MSSQL database connection.
- *
- * @example
- * ```typescript
- * const options: MSSQLDatabaseOptions = {
- *   databaseName: 'my_database',
- *   host: 'localhost',
- *   port: 1433,
- *   user: 'sa',
- *   password: 'Password123',
- *   encrypt: true,
- *   poolMin: 5,
- *   poolMax: 20,
- *   debug: true,
- *   pulse: true
- * };
- * ```
  */
 export interface MSSQLDatabaseOptions {
     /** The name of the database to connect to. */
-    databaseName: string;
+    readonly databaseName: string;
     /** The host of the database server. */
-    host: string;
+    readonly host: string;
     /** The port number for the database connection. */
-    port: number;
+    readonly port: number;
     /** The username for authenticating with the database. */
-    user: string;
+    readonly user: string;
     /** The password for authenticating with the database. */
-    password: string;
+    readonly password: string;
     /**
      * Whether to encrypt the database connection.
      * When enabled, communication between the client and server will be encrypted,
-     * providing increased security but potentially slight performance impact.
      *
      * @defaultValue true
      */
-    encrypt?: boolean;
+    readonly encrypt?: boolean;
     /**
      * Minimum number of connections in the connection pool.
      * This represents the minimum number of connections that will be maintained in the pool,
@@ -44,7 +27,7 @@ export interface MSSQLDatabaseOptions {
      *
      * @defaultValue 2
      */
-    poolMin?: number;
+    readonly poolMin?: number;
     /**
      * Maximum number of connections in the connection pool.
      * This limits how many concurrent connections can be established to the database.
@@ -53,32 +36,28 @@ export interface MSSQLDatabaseOptions {
      *
      * @defaultValue 10
      */
-    poolMax?: number;
+    readonly poolMax?: number;
     /**
      * The timeout in milliseconds for acquiring a connection.
      * If a connection cannot be acquired within this timeframe, an error will be thrown.
      *
      * @defaultValue 20000
      */
-    connectionTimeout?: number;
+    readonly connectionTimeout?: number;
     /**
-     * If set to true, adds basic event listeners for all tables.
-     * This automatically sets up event listeners to track database operations
-     * (select, create, update, delete) for all tables, allowing for easy monitoring
-     * and event-driven programming.
-     *
-     * [TODO] - Change this section when working on the AND-169 ticket.
+     * If set to true, emits events for database operations.
+     * (select, create, update, delete) for all tables.
      *
      * @defaultValue false
      * @example
-     * ```typescript
+     * ```ts
      * const mssql = new MSSQL(options);
      * await mssql.connect();
-     * // SELECTED, CREATED, UPDATED, DELETED
-     * mssql.table('table_name').on(EVENT_TABLE.SELECTED, (data: unknown) => {
-     *    console.log(data); // data is the response from the query
+     * // selected, inserted, updated, deleted
+     * mssql.table('table_name').on('selected', (data: unknown) => {
+     *   console.log(data); // data is the response from the query
      * });
      * ```
      */
-    isEventEnabled?: boolean;
+    readonly isEventEnabled?: boolean;
 }

package/dist/modules/database/types/mssqlEventLog.d.ts

@@ -0,0 +1,14 @@
+export interface MssqlEventLog {
+    /** The name of the database where the query was executed. */
+    readonly database: string;
+    /** A list of tables affected by the query. */
+    readonly tables: string[];
+    /** A unique identifier for the executed query. */
+    readonly queryUuid: string;
+    /** The method used in the query (e.g., `SELECT`, `INSERT`, `UPDATE`, `DELETE`). */
+    readonly method: string;
+    /** The raw SQL query string. */
+    readonly sql: string;
+    /** The parameters or bindings used in the query. */
+    readonly bindings: unknown[];
+}

package/dist/modules/database/types/queryContext.d.ts

@@ -0,0 +1,11 @@
+export interface QueryContext {
+    readonly method: string;
+    readonly options: Record<string, unknown>;
+    readonly timeout: number;
+    readonly cancelOnTimeout: boolean;
+    readonly bindings: unknown[];
+    readonly sql: string;
+    readonly queryContext: Record<string, unknown>;
+    readonly __knexUid: string;
+    readonly __knexQueryUid: string;
+}

package/dist/modules/elysia/crud/crud.d.ts

@@ -0,0 +1,46 @@
+import type { TObject, TString } from '@sinclair/typebox';
+import { Elysia, type SingletonBase } from 'elysia';
+import type { MSSQL } from '../../../modules/database/mssql';
+import type { CrudModelsType } from '../../../modules/elysia/crudSchema/types/crudModelsType';
+import type { DynamicDbOptions } from '../../../modules/elysia/dbResolver/types/dynamicDbOptions';
+import type { CrudOperationCountOptions } from './types/crudOperationCountOptions';
+import type { CrudOperationDeleteOneOptions } from './types/crudOperationDeleteOneOptions';
+import type { CrudOperationDeleteOptions } from './types/crudOperationDeleteOptions';
+import type { CrudOperationFindOneOptions } from './types/crudOperationFindOneOptions';
+import type { CrudOperationFindOptions } from './types/crudOperationFindOptions';
+import type { CrudOperationInsertOptions } from './types/crudOperationInsertOptions';
+import type { CrudOperationsOptions } from './types/crudOperationsOptions';
+import type { CrudOperationUpdateOneOptions } from './types/crudOperationUpdateOneOptions';
+import type { CrudOperationUpdateOptions } from './types/crudOperationUpdateOptions';
+import type { CrudOptions } from './types/crudOptions';
+export declare const crud: <const TDatabase extends DynamicDbOptions | string, const TTableName extends string, const TSourceSchema extends TObject, const TOperations extends CrudOperationsOptions = {
+    find: true;
+    findOne: true;
+    insert: true;
+    update: true;
+    updateOne: true;
+    delete: true;
+    deleteOne: true;
+    count: true;
+}, const TSourceFindSchema extends TObject = TSourceSchema, const TSourceCountSchema extends TObject = TSourceSchema, const TSourceInsertSchema extends TObject = TSourceSchema, const TSourceUpdateSchema extends TObject = TSourceSchema, const TSourceDeleteSchema extends TObject = TSourceSchema, const TSourceResponseSchema extends TObject = TSourceSchema>({ database, tableName, schema, operations }: CrudOptions<TDatabase, TTableName, TSourceSchema, TOperations, TSourceFindSchema, TSourceCountSchema, TSourceInsertSchema, TSourceUpdateSchema, TSourceDeleteSchema, TSourceResponseSchema>) => Elysia<TTableName, {
+    decorator: SingletonBase["decorator"];
+    store: SingletonBase["store"];
+    derive: SingletonBase["derive"];
+    resolve: Record<TDatabase extends string ? "staticDB" : "dynamicDB", MSSQL>;
+}, {
+    typebox: CrudModelsType<TTableName, {
+        find: TOperations["find"] extends true | CrudOperationFindOptions ? true : false;
+        findOne: TOperations["findOne"] extends true | CrudOperationFindOneOptions ? true : false;
+        insert: TOperations["insert"] extends true | CrudOperationInsertOptions ? true : false;
+        update: TOperations["update"] extends true | CrudOperationUpdateOptions ? true : false;
+        updateOne: TOperations["updateOne"] extends true | CrudOperationUpdateOneOptions ? true : false;
+        delete: TOperations["delete"] extends true | CrudOperationDeleteOptions ? true : false;
+        deleteOne: TOperations["deleteOne"] extends true | CrudOperationDeleteOneOptions ? true : false;
+        count: TOperations["count"] extends true | CrudOperationCountOptions ? true : false;
+    }, TSourceInsertSchema, TSourceFindSchema, TSourceCountSchema, TSourceUpdateSchema, TSourceDeleteSchema, TSourceResponseSchema> & {
+        ResolveDbHeader: TObject<{
+            "database-using": TString;
+        }>;
+    };
+    error: {};
+}>;

package/dist/modules/elysia/crud/index.d.ts

@@ -0,0 +1 @@
+export { crud } from './crud';

package/dist/modules/elysia/crud/index.js

@@ -0,0 +1,299 @@
+// @bun
+import {
+  crudSchema
+} from "../../../chunk-s07amdhx.js";
+import"../../../chunk-f5z7x01b.js";
+import {
+  dbResolver
+} from "../../../chunk-v8v7982b.js";
+import"../../../chunk-370444pc.js";
+import"../../../chunk-cq973ydc.js";
+import"../../../chunk-pc66jgqv.js";
+import"../../../chunk-1a3wj3m1.js";
+import"../../../chunk-5qtpggzv.js";
+import"../../../chunk-yvyahr2h.js";
+import"../../../chunk-84mqvfsk.js";
+import"../../../chunk-vknq69e0.js";
+
+// source/modules/elysia/crud/crud.ts
+import { Elysia, t } from "elysia";
+var _createDefaultOperationsWithHandlers = (tableName, database) => {
+  const _requiredHeaderDatabase = typeof database === "object" ? { headers: "dbSelectorHeader" } : {};
+  return {
+    insert: {
+      method: "POST",
+      path: "/",
+      hook: {
+        ..._requiredHeaderDatabase,
+        body: `${tableName}Insert`,
+        response: `${tableName}Response200`
+      },
+      handler: 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: `Inserted record into ${tableName}`,
+          content: data
+        };
+      }
+    },
+    find: {
+      method: "POST",
+      path: "/search",
+      hook: {
+        ..._requiredHeaderDatabase,
+        body: `${tableName}Find`,
+        response: `${tableName}Response200`
+      },
+      handler: async (ctx) => {
+        const db = ctx.dynamicDB || ctx.staticDB;
+        const body = ctx.body;
+        const data = await db.getRepository(tableName).find({
+          ...body.queryOptions,
+          throwIfNoResult: true
+        });
+        return {
+          message: `Found ${data.length} records for ${tableName}`,
+          content: data
+        };
+      }
+    },
+    findOne: {
+      method: "GET",
+      path: "/:id",
+      hook: {
+        ..._requiredHeaderDatabase,
+        params: t.Object({
+          id: t.Union([
+            t.String({
+              format: "uuid"
+            }),
+            t.Number({
+              minimum: 1,
+              maximum: Number.MAX_SAFE_INTEGER
+            })
+          ])
+        }),
+        response: `${tableName}Response200`
+      },
+      handler: 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: true
+        });
+        return {
+          message: `Found record with id ${id} in ${tableName}`,
+          content: data
+        };
+      }
+    },
+    count: {
+      method: "POST",
+      path: "/count",
+      hook: {
+        ..._requiredHeaderDatabase,
+        body: `${tableName}Count`,
+        response: `${tableName}CountResponse200`
+      },
+      handler: 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: `Counted records in ${tableName}`,
+          content: data
+        };
+      }
+    },
+    update: {
+      method: "PATCH",
+      path: "/",
+      hook: {
+        ..._requiredHeaderDatabase,
+        body: `${tableName}Update`,
+        response: `${tableName}Response200`
+      },
+      handler: 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: data.length === 0 ? `No records updated in ${tableName}` : `Updated records in ${tableName}`,
+          content: data
+        };
+      }
+    },
+    updateOne: {
+      method: "PATCH",
+      path: "/:id",
+      hook: {
+        ..._requiredHeaderDatabase,
+        params: t.Object({
+          id: t.Union([
+            t.String({
+              format: "uuid"
+            }),
+            t.Number({
+              minimum: 1,
+              maximum: Number.MAX_SAFE_INTEGER
+            })
+          ])
+        }),
+        body: `${tableName}UpdateOne`,
+        response: `${tableName}Response200`
+      },
+      handler: 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: true
+        });
+        return {
+          message: `Updated record with id ${id} in ${tableName}`,
+          content: data
+        };
+      }
+    },
+    delete: {
+      method: "DELETE",
+      path: "/",
+      hook: {
+        ..._requiredHeaderDatabase,
+        body: `${tableName}Delete`,
+        response: `${tableName}Response200`
+      },
+      handler: 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: `Deleted records from ${tableName}`,
+          content: data
+        };
+      }
+    },
+    deleteOne: {
+      method: "DELETE",
+      path: "/:id",
+      hook: {
+        ..._requiredHeaderDatabase,
+        params: t.Object({
+          id: t.Union([
+            t.String({
+              format: "uuid"
+            }),
+            t.Number({
+              minimum: 1,
+              maximum: Number.MAX_SAFE_INTEGER
+            })
+          ])
+        }),
+        body: `${tableName}DeleteOne`,
+        response: `${tableName}Response200`
+      },
+      handler: async (ctx) => {
+        const db = ctx.dynamicDB || ctx.staticDB;
+        const { id } = ctx.params;
+        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: `Deleted record with id ${id} from ${tableName}`,
+          content: data
+        };
+      }
+    }
+  };
+};
+var _addRoutesByOperations = (tableName, database, operations) => {
+  const app = new Elysia;
+  const _defaultOperations = _createDefaultOperationsWithHandlers(tableName, database);
+  for (const operationKey in operations) {
+    const operation = operations[operationKey];
+    const defaultOperation = _defaultOperations[operationKey];
+    if (!operation || !defaultOperation)
+      continue;
+    if (typeof operation === "boolean") {
+      app.route(defaultOperation.method, defaultOperation.path, (ctx) => defaultOperation.handler(ctx), defaultOperation.hook);
+    } else if (typeof operation === "object") {
+      const mergedOperation = {
+        ...defaultOperation,
+        ...operation
+      };
+      app.route(mergedOperation.method, mergedOperation.path, (ctx) => defaultOperation.handler(ctx), mergedOperation.hook);
+    }
+  }
+  return app;
+};
+var crud = ({
+  database,
+  tableName,
+  schema,
+  operations = {
+    find: true,
+    findOne: true,
+    insert: true,
+    update: true,
+    updateOne: true,
+    delete: true,
+    deleteOne: true,
+    count: true
+  }
+}) => new Elysia({
+  name: `crudPlugin[${tableName}]`,
+  tags: [tableName]
+}).use(dbResolver(database)).use(crudSchema({
+  sourceSchemaName: tableName,
+  sourceSchema: schema.sourceSchema,
+  sourceInsertSchema: schema.sourceInsertSchema || schema.sourceSchema,
+  sourceFindSchema: schema.sourceFindSchema || schema.sourceSchema,
+  sourceCountSchema: schema.sourceCountSchema || schema.sourceSchema,
+  sourceUpdateSchema: schema.sourceUpdateSchema || schema.sourceSchema,
+  sourceDeleteSchema: schema.sourceDeleteSchema || schema.sourceSchema,
+  sourceResponseSchema: schema.sourceResponseSchema || schema.sourceSchema,
+  operations: {
+    find: operations.find ? true : false,
+    findOne: operations.findOne ? true : false,
+    insert: operations.insert ? true : false,
+    update: operations.update ? true : false,
+    updateOne: operations.updateOne ? true : false,
+    delete: operations.delete ? true : false,
+    deleteOne: operations.deleteOne ? true : false,
+    count: operations.count ? true : false
+  }
+})).use(_addRoutesByOperations(tableName, database, operations));
+export {
+  crud
+};

package/dist/modules/elysia/crud/types/crudOperationBaseOptions.d.ts

@@ -0,0 +1,6 @@
+import type { BaseMacro, InputSchema, LocalHook, RouteSchema, SingletonBase } from 'elysia/types';
+export interface CrudOperationBaseOptions {
+    readonly path?: string;
+    readonly method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    readonly hook?: LocalHook<InputSchema, RouteSchema, SingletonBase, Record<string, Error>, BaseMacro>;
+}

package/dist/modules/elysia/crud/types/crudOperationCountOptions.d.ts

@@ -0,0 +1,2 @@
+import type { CrudOperationBaseOptions } from './crudOperationBaseOptions';
+export type CrudOperationCountOptions = CrudOperationBaseOptions;

package/dist/modules/elysia/crud/types/crudOperationDeleteOneOptions.d.ts

@@ -0,0 +1,2 @@
+import type { CrudOperationBaseOptions } from './crudOperationBaseOptions';
+export type CrudOperationDeleteOneOptions = CrudOperationBaseOptions;

package/dist/modules/elysia/crud/types/crudOperationDeleteOptions.d.ts

@@ -0,0 +1,2 @@
+import type { CrudOperationBaseOptions } from './crudOperationBaseOptions';
+export type CrudOperationDeleteOptions = CrudOperationBaseOptions;

package/dist/modules/elysia/crud/types/crudOperationFindOneOptions.d.ts

@@ -0,0 +1,2 @@
+import type { CrudOperationBaseOptions } from './crudOperationBaseOptions';
+export type CrudOperationFindOneOptions = CrudOperationBaseOptions;

package/dist/modules/elysia/crud/types/crudOperationFindOptions.d.ts

@@ -0,0 +1,2 @@
+import type { CrudOperationBaseOptions } from './crudOperationBaseOptions';
+export type CrudOperationFindOptions = CrudOperationBaseOptions;

package/dist/modules/elysia/crud/types/crudOperationInsertOptions.d.ts

@@ -0,0 +1,2 @@
+import type { CrudOperationBaseOptions } from './crudOperationBaseOptions';
+export type CrudOperationInsertOptions = CrudOperationBaseOptions;