@c15t/backend 0.0.1-rc.10

package/dist/db/create-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-registry.d.ts","sourceRoot":"","sources":["../../src/db/create-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAgBvD,eAAO,MAAM,cAAc,GAAI,KAAK,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAeu+D,CAAC;yBAA8B,CAAC;iBAAsB,CAAC;eAAoB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAA1N,CAAC;kBAAuB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CADp6D,CAAC"}

package/dist/db/hooks/create-hooks.d.ts

@@ -0,0 +1,32 @@
+import type { Adapter } from '../adapters/types';
+import type { CreateWithHooksProps, HookContext } from './types';
+/**
+ * Creates a record with hooks applied before and after creation.
+ *
+ * @typeParam TInputData - Type of the data being created
+ * @typeParam TOutputData - Type of the data returned after creation
+ *
+ * @param adapter - The database adapter to use
+ * @param ctx - Context containing hooks and options
+ * @param props - Properties for the create operation
+ * @returns The created record or null if a hook aborted the operation
+ *
+ * @remarks
+ * This function orchestrates the entity creation process, executing hooks
+ * at appropriate times to allow validation, transformation, and post-processing.
+ * It supports both standard adapter-based creation and custom creation functions.
+ *
+ * @example
+ * ```typescript
+ * const subject = await createWithHook(
+ *   mysqlAdapter,
+ *   { hooks: subjectHooks, options: config },
+ *   {
+ *     data: { name: 'Alice' },
+ *     model: 'subject'
+ *   }
+ * );
+ * ```
+ */
+export declare function createWithHook<TInputData extends Record<string, unknown> = Record<string, unknown>, TOutputData extends Record<string, unknown> = TInputData>(adapter: Adapter, ctx: HookContext, props: CreateWithHooksProps<TInputData>): Promise<TOutputData | null>;
+//# sourceMappingURL=create-hooks.d.ts.map

package/dist/db/hooks/create-hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-hooks.d.ts","sourceRoot":"","sources":["../../../src/db/hooks/create-hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAEjD,OAAO,KAAK,EAAE,oBAAoB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAGjE;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAsB,cAAc,CACnC,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpE,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,UAAU,EAExD,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,WAAW,EAChB,KAAK,EAAE,oBAAoB,CAAC,UAAU,CAAC,GACrC,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CA+C7B"}

package/dist/db/hooks/index.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Database Hooks Module
+ *
+ * A comprehensive system for intercepting, validating, and transforming data
+ * during database operations. Hooks provide a powerful way to implement
+ * cross-cutting concerns like validation, authorization, and data enrichment.
+ *
+ * This module provides:
+ * - Type definitions for hooks and their operations
+ * - Core hook processing utilities
+ * - Operation-specific hook implementations (create, update, updateMany)
+ * - A factory for generating hook-enabled database operations
+ *
+ * @module db/hooks
+ *
+ * @example
+ * ```typescript
+ * import { getWithHooks } from '~/db/hooks';
+ * import { adapter } from '~/adapters';
+ *
+ * // Create hook-enabled database operations
+ * const { createWithHooks } = getWithHooks(adapter, {
+ *   options: config,
+ *   hooks: config.databaseHooks || []
+ * });
+ *
+ * // Use hooks with database operations
+ * const subject = await createWithHooks({
+ *   data: { name: 'Alice', email: 'alice@example.com' },
+ *   model: 'subject'
+ * });
+ * ```
+ */
+export * from './types';
+export * from './utils';
+export * from './create-hooks';
+export * from './update-hooks';
+export * from './update-many-hooks';
+export * from './with-hooks-factory';
+//# sourceMappingURL=index.d.ts.map

package/dist/db/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/db/hooks/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC"}

package/dist/db/hooks/types.d.ts

@@ -0,0 +1,133 @@
+import type { Where } from '../adapters/types';
+import type { C15TOptions, GenericEndpointContext } from '../../types';
+import type { EntityName, EntityTypeMap } from '../core/types';
+/**
+ * Defines execution phases when hooks can run in the database operation lifecycle.
+ */
+export type HookPhase = 'before' | 'after';
+/**
+ * Defines database operations that can have hooks attached.
+ */
+export type HookOperation = 'create' | 'update';
+/**
+ * Result types for hook execution that control the flow of operations.
+ *
+ * @typeParam TData - The data type being processed by the hook
+ *
+ * @remarks
+ * Hook functions can return different result types to control operation flow:
+ * - `{ kind: 'abort' }` - Abort the operation entirely
+ * - `{ kind: 'transform', data: TData }` - Transform the data and continue
+ * - `{ kind: 'continue' }` - Continue with unchanged data
+ *
+ * @example
+ * ```typescript
+ * // Abort if validation fails
+ * if (!isValid(data)) {
+ *   return { kind: 'abort' };
+ * }
+ * ```
+ */
+export type HookResult<TData> = {
+    kind: 'abort';
+} | {
+    kind: 'transform';
+    data: TData;
+} | {
+    kind: 'continue';
+};
+/**
+ * Hook function for a specific entity type, providing before/after hooks
+ * for create and update operations.
+ *
+ * @typeParam TEntityName - The entity type this hook applies to
+ *
+ * @remarks
+ * ModelHook provides a structured way to define hooks for different
+ * database operations on a specific entity type.
+ *
+ * @example
+ * ```typescript
+ * const subjectHook: ModelHook<'subject'> = {
+ *   create: {
+ *     before: (subjectData) => ({
+ *       kind: 'transform',
+ *       data: { ...subjectData, createdAt: new Date() }
+ *     })
+ *   }
+ * };
+ * ```
+ */
+export interface ModelHook<TEntityName extends EntityName = EntityName> {
+    create?: {
+        before?: (data: EntityTypeMap[TEntityName], context?: GenericEndpointContext) => Promise<HookResult<EntityTypeMap[TEntityName]> | undefined> | HookResult<EntityTypeMap[TEntityName]> | undefined;
+        after?: (data: EntityTypeMap[TEntityName], context?: GenericEndpointContext) => Promise<void> | void;
+    };
+    update?: {
+        before?: (data: Partial<EntityTypeMap[TEntityName]>, context?: GenericEndpointContext) => Promise<HookResult<Partial<EntityTypeMap[TEntityName]>> | undefined> | HookResult<Partial<EntityTypeMap[TEntityName]>> | undefined;
+        after?: (data: EntityTypeMap[TEntityName], context?: GenericEndpointContext) => Promise<void> | void;
+    };
+}
+/**
+ * A collection of hooks for different entity types in the database.
+ *
+ * @remarks
+ * This is the primary way to register hooks in the system.
+ */
+export type DatabaseHook = {
+    [TEntityName in EntityName]?: ModelHook<TEntityName>;
+};
+/**
+ * Context object containing application options and registered hooks.
+ */
+export interface HookContext {
+    hooks: DatabaseHook[];
+    options: C15TOptions;
+}
+/**
+ * Interface for defining custom operation functions that can be used
+ * in place of or alongside standard database operations.
+ *
+ * @typeParam TInputData - The input data type for the operation
+ * @typeParam TOutputData - The output data type for the operation
+ *
+ * @remarks
+ * Custom functions allow for specialized behavior when standard
+ * CRUD operations aren't sufficient.
+ */
+export interface CustomOperationFunction<TInputData extends Record<string, unknown> = Record<string, unknown>, TOutputData = TInputData> {
+    fn: (data: TOutputData) => Promise<TOutputData | null> | TOutputData | null;
+    executeMainFn?: boolean;
+}
+/**
+ * Properties for creating a record with hooks.
+ *
+ * @typeParam TData - The data type being created
+ *
+ * @remarks
+ * This is the parameter object for the createWithHook function.
+ */
+export interface CreateWithHooksProps<TData extends Record<string, unknown> = Record<string, unknown>> {
+    data: TData;
+    model: EntityName;
+    customFn?: CustomOperationFunction<TData>;
+    context?: GenericEndpointContext;
+}
+/**
+ * Properties for updating records with hooks.
+ *
+ * @typeParam TInputData - The input data type for the update
+ * @typeParam TOutputData - The expected output data type
+ * @typeParam TResultData - The final result data type
+ *
+ * @remarks
+ * This is the parameter object for updateWithHooks and updateManyWithHooks functions.
+ */
+export interface UpdateWithHooksProps<TInputData extends Record<string, unknown> = Record<string, unknown>, TOutputData = TInputData, TResultData = TOutputData> {
+    data: Partial<TInputData>;
+    where: Where<EntityName>;
+    model: EntityName;
+    customFn?: CustomOperationFunction<Partial<TInputData>, TResultData>;
+    context?: GenericEndpointContext;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/db/hooks/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/db/hooks/types.ts"],"names":[],"mappings":"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"}

package/dist/db/hooks/update-hooks.d.ts

@@ -0,0 +1,33 @@
+import type { Adapter } from '../adapters/types';
+import type { HookContext, UpdateWithHooksProps } from './types';
+/**
+ * Updates a record with hooks applied before and after the update operation.
+ *
+ * @typeParam TInputData - Type of the data being updated
+ * @typeParam TOutputData - Type of the data returned after update
+ *
+ * @param adapter - The database adapter to use
+ * @param ctx - Context containing hooks and options
+ * @param props - Properties for the update operation
+ * @returns The updated record or null if a hook aborted the operation
+ *
+ * @remarks
+ * This function orchestrates the entity update process, executing hooks
+ * at appropriate times to allow validation, transformation, and post-processing.
+ * It supports both standard adapter-based updates and custom update functions.
+ *
+ * @example
+ * ```typescript
+ * const updatedSubject = await updateWithHooks(
+ *   mysqlAdapter,
+ *   { hooks: subjectHooks, options: config },
+ *   {
+ *     data: { status: 'active' },
+ *     where: { id: 'sub_x1pftyoufsm7xgo1kv' },
+ *     model: 'subject'
+ *   }
+ * );
+ * ```
+ */
+export declare function updateWithHooks<TInputData extends Record<string, unknown> = Record<string, unknown>, TOutputData extends Record<string, unknown> = TInputData>(adapter: Adapter, ctx: HookContext, props: UpdateWithHooksProps<TInputData, TOutputData>): Promise<TOutputData | null>;
+//# sourceMappingURL=update-hooks.d.ts.map

package/dist/db/hooks/update-hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-hooks.d.ts","sourceRoot":"","sources":["../../../src/db/hooks/update-hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAEjD,OAAO,KAAK,EAAE,WAAW,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAGjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,eAAe,CACpC,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpE,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,UAAU,EAExD,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,WAAW,EAChB,KAAK,EAAE,oBAAoB,CAAC,UAAU,EAAE,WAAW,CAAC,GAClD,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAiD7B"}

package/dist/db/hooks/update-many-hooks.d.ts

@@ -0,0 +1,55 @@
+import type { Adapter } from '../adapters/types';
+import type { HookContext, UpdateWithHooksProps } from './types';
+/**
+ * Updates multiple records with hooks applied before and after the batch update.
+ *
+ * This function orchestrates the batch update process, executing hooks
+ * at appropriate times to allow validation, transformation, and post-processing
+ * for multiple records simultaneously.
+ *
+ * @template TInputData - Type of the data being updated
+ * @template TOutputData - Type of the data returned after update
+ *
+ * @param adapter - The database adapter to use
+ * @param ctx - Context containing hooks and options
+ * @param props - Properties for the updateMany operation
+ *
+ * @returns The updated records or null if a hook aborted the operation
+ *
+ * @example
+ * ```typescript
+ * // Batch update subjects
+ * const updatedSubjects = await updateManyWithHooks(
+ *   mysqlAdapter,
+ *   { hooks: subjectHooks, options: config },
+ *   {
+ *     data: { isVerified: true },
+ *     where: { emailDomain: 'example.com' },
+ *     model: 'subject'
+ *   }
+ * );
+ *
+ * // With custom function for complex batch processing
+ * const updatedPosts = await updateManyWithHooks(
+ *   mysqlAdapter,
+ *   { hooks: postHooks, options: config },
+ *   {
+ *     data: { isArchived: true },
+ *     where: { createdAt: { lt: oneYearAgo } },
+ *     model: 'post',
+ *     customFn: {
+ *       fn: async (data) => {
+ *         // Get posts to be archived
+ *         const postsToArchive = await postService.findOldPosts();
+ *         // Custom batch processing
+ *         const archivedPosts = await postService.batchArchive(postsToArchive, data);
+ *         return archivedPosts;
+ *       },
+ *       executeMainFn: false // Skip standard update as custom function handles it
+ *     }
+ *   }
+ * );
+ * ```
+ */
+export declare function updateManyWithHooks<TInputData extends Record<string, unknown> = Record<string, unknown>, TOutputData extends Record<string, unknown> = TInputData>(adapter: Adapter, ctx: HookContext, props: UpdateWithHooksProps<TInputData, TOutputData>): Promise<TOutputData[] | null>;
+//# sourceMappingURL=update-many-hooks.d.ts.map

package/dist/db/hooks/update-many-hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-many-hooks.d.ts","sourceRoot":"","sources":["../../../src/db/hooks/update-many-hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAEnD,OAAO,KAAK,EAEX,WAAW,EACX,oBAAoB,EACpB,MAAM,SAAS,CAAC;AA4DjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,wBAAsB,mBAAmB,CACxC,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpE,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,UAAU,EAExD,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,WAAW,EAChB,KAAK,EAAE,oBAAoB,CAAC,UAAU,EAAE,WAAW,CAAC,GAClD,OAAO,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,CAmD/B"}

package/dist/db/hooks/utils.d.ts

@@ -0,0 +1,62 @@
+import type { GenericEndpointContext } from '../../types';
+import type { EntityName } from '../core/types';
+import type { DatabaseHook, HookOperation, HookPhase } from './types';
+/**
+ * Process hooks for a given phase and operation.
+ *
+ * @typeParam TEntityData - Type of the entity data being processed
+ *
+ * @param data - The data to process through hooks
+ * @param model - The entity type/model name
+ * @param operation - The operation being performed (create/update)
+ * @param phase - The hook execution phase (before/after)
+ * @param hooks - Array of hook sets to process
+ * @param context - Optional request context
+ * @returns The processed data, potentially transformed, or null if aborted
+ *
+ * @remarks
+ * This core utility function handles the execution of hooks for various
+ * database operations. It traverses all registered hooks for the specified
+ * entity, operation, and phase, applying transformations or aborting as needed.
+ *
+ * @example
+ * ```typescript
+ * const processedData = await processHooks(
+ *   { name: 'Alice' },
+ *   'subject',
+ *   'create',
+ *   'before',
+ *   registeredHooks
+ * );
+ * ```
+ */
+export declare function processHooks<TEntityName extends EntityName, TEntityData extends Record<string, unknown>>(data: TEntityData, model: TEntityName, operation: HookOperation, phase: HookPhase, hooks: DatabaseHook[], context?: GenericEndpointContext): Promise<TEntityData | null>;
+/**
+ * Process hooks for multiple records.
+ *
+ * @typeParam TEntityName - Type of the entity name
+ * @typeParam TEntityData - Type of the entity data
+ *
+ * @param records - Array of records to process
+ * @param model - The entity type/model name
+ * @param hooks - Array of hook sets to process
+ * @param context - Optional request context
+ * @returns Promise that resolves when all hooks have been processed
+ *
+ * @remarks
+ * This utility function handles processing after-update hooks for a batch
+ * of records, ensuring each record goes through the appropriate hooks.
+ *
+ * @example
+ * ```typescript
+ * // Process 'after update' hooks for multiple subjects
+ * await processAfterHooksForMany(
+ *   updatedSubjects,
+ *   'subject',
+ *   registeredHooks,
+ *   { batchId: 'sub_x1pftyoufsm7xgo1kv' }
+ * );
+ * ```
+ */
+export declare function processAfterHooksForMany<TEntityName extends EntityName, TEntityData extends Record<string, unknown>>(records: TEntityData[], model: TEntityName, hooks: DatabaseHook[], context?: GenericEndpointContext): Promise<void>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/db/hooks/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/db/hooks/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,KAAK,EAAE,UAAU,EAAiB,MAAM,eAAe,CAAC;AAC/D,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,YAAY,CACjC,WAAW,SAAS,UAAU,EAC9B,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAE3C,IAAI,EAAE,WAAW,EACjB,KAAK,EAAE,WAAW,EAClB,SAAS,EAAE,aAAa,EACxB,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,YAAY,EAAE,EACrB,OAAO,CAAC,EAAE,sBAAsB,GAC9B,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAuD7B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,wBAAwB,CAC7C,WAAW,SAAS,UAAU,EAC9B,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAE3C,OAAO,EAAE,WAAW,EAAE,EACtB,KAAK,EAAE,WAAW,EAClB,KAAK,EAAE,YAAY,EAAE,EACrB,OAAO,CAAC,EAAE,sBAAsB,GAC9B,OAAO,CAAC,IAAI,CAAC,CAef"}

package/dist/db/hooks/with-hooks-factory.d.ts

@@ -0,0 +1,33 @@
+import type { Adapter } from '../adapters/types';
+import type { CreateWithHooksProps, HookContext, UpdateWithHooksProps } from './types';
+/**
+ * Creates a set of functions that apply hooks before and after database operations.
+ *
+ * @param adapter - The database adapter to use for operations
+ * @param ctx - Context object containing options and hooks
+ * @returns Object with hook-enabled database operation functions
+ *
+ * @remarks
+ * This factory function generates hook-enabled versions of common database operations
+ * (create, update, updateMany), allowing for consistent hook processing across
+ * the application.
+ *
+ * @example
+ * ```typescript
+ * const { createWithHooks } = getWithHooks(adapter, {
+ *   options: c15tOptions,
+ *   hooks: c15tOptions.databaseHooks || []
+ * });
+ *
+ * const subject = await createWithHooks({
+ *   data: { name: 'Alice' },
+ *   model: 'subject'
+ * });
+ * ```
+ */
+export declare function getWithHooks(adapter: Adapter, ctx: HookContext): {
+    createWithHooks: <TInputData extends Record<string, unknown>, TOutputData extends Record<string, unknown> = TInputData>({ data, model, customFn, context, }: CreateWithHooksProps<TInputData>) => Promise<TOutputData | null>;
+    updateWithHooks: <TInputData extends Record<string, unknown>, TOutputData extends Record<string, unknown> = TInputData>(props: UpdateWithHooksProps<TInputData, TOutputData>) => Promise<TOutputData | null>;
+    updateManyWithHooks: <TInputData extends Record<string, unknown>, TOutputData extends Record<string, unknown> = TInputData>(props: UpdateWithHooksProps<TInputData, TOutputData>) => Promise<TOutputData[] | null>;
+};
+//# sourceMappingURL=with-hooks-factory.d.ts.map

package/dist/db/hooks/with-hooks-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"with-hooks-factory.d.ts","sourceRoot":"","sources":["../../../src/db/hooks/with-hooks-factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAEnD,OAAO,KAAK,EACX,oBAAoB,EACpB,WAAW,EACX,oBAAoB,EACpB,MAAM,SAAS,CAAC;AAIjB;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,WAAW;sBAG5D,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC1C,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,oDAMzC,oBAAoB,CAAC,UAAU,CAAC;sBASlC,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC1C,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,sBAEpC,oBAAoB,CAAC,UAAU,EAAE,WAAW,CAAC;0BAIpD,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC1C,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,sBAEpC,oBAAoB,CAAC,UAAU,EAAE,WAAW,CAAC;EAGtD"}