@c15t/backend 0.0.1-rc.10

package/dist/db/migration/migration-builders.d.ts

@@ -0,0 +1,28 @@
+import type { Kysely } from 'kysely';
+import type { Database, KyselyDatabaseType } from '../adapters/kysely-adapter/types';
+import type { ColumnsToAdd, MigrationOperation, TableToCreate } from './types';
+/**
+ * Builds migrations for adding columns to existing tables
+ *
+ * This function creates ALTER TABLE statements to add missing columns
+ * to existing tables in the database.
+ *
+ * @param db - Kysely database instance used to build SQL operations
+ * @param toBeAdded - Collection of tables and columns that need to be added
+ * @param dbType - Database type to determine appropriate column types
+ * @returns Array of migration operations ready to be executed
+ */
+export declare function buildColumnAddMigrations(db: Kysely<Database>, toBeAdded: ColumnsToAdd[], dbType: KyselyDatabaseType): MigrationOperation[];
+/**
+ * Builds migrations for creating new tables
+ *
+ * This function creates CREATE TABLE statements for tables
+ * that don't exist in the database but are defined in the schema.
+ *
+ * @param db - Kysely database instance used to build SQL operations
+ * @param toBeCreated - Collection of tables that need to be created
+ * @param dbType - Database type to determine appropriate column types
+ * @returns Array of migration operations ready to be executed
+ */
+export declare function buildTableCreateMigrations(db: Kysely<Database>, toBeCreated: TableToCreate[], dbType: KyselyDatabaseType): MigrationOperation[];
+//# sourceMappingURL=migration-builders.d.ts.map

package/dist/db/migration/migration-builders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration-builders.d.ts","sourceRoot":"","sources":["../../../src/db/migration/migration-builders.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAA8B,MAAM,EAAE,MAAM,QAAQ,CAAC;AACjE,OAAO,KAAK,EACX,QAAQ,EACR,kBAAkB,EAClB,MAAM,oCAAoC,CAAC;AAI5C,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE/E;;;;;;;;;;GAUG;AACH,wBAAgB,wBAAwB,CACvC,EAAE,EAAE,MAAM,CAAC,QAAQ,CAAC,EACpB,SAAS,EAAE,YAAY,EAAE,EACzB,MAAM,EAAE,kBAAkB,GACxB,kBAAkB,EAAE,CA0CtB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CACzC,EAAE,EAAE,MAAM,CAAC,QAAQ,CAAC,EACpB,WAAW,EAAE,aAAa,EAAE,EAC5B,MAAM,EAAE,kBAAkB,GACxB,kBAAkB,EAAE,CAqFtB"}

package/dist/db/migration/migration-execution.d.ts

@@ -0,0 +1,12 @@
+import type { MigrationOperation } from './types';
+/**
+ * Creates functions to run or compile the generated migrations
+ *
+ * @param migrations - Migration operations to execute
+ * @returns Object with runMigrations and compileMigrations functions
+ */
+export declare function createMigrationExecutors(migrations: MigrationOperation[]): {
+    runMigrations: () => Promise<void>;
+    compileMigrations: () => Promise<string>;
+};
+//# sourceMappingURL=migration-execution.d.ts.map

package/dist/db/migration/migration-execution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration-execution.d.ts","sourceRoot":"","sources":["../../../src/db/migration/migration-execution.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAElD;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,kBAAkB,EAAE;;;EA8DxE"}

package/dist/db/migration/schema-comparison.d.ts

@@ -0,0 +1,54 @@
+import type { TableMetadata } from 'kysely';
+/**
+ * Schema comparison functionality for database migrations
+ *
+ * This module analyzes differences between the expected schema definition and the
+ * actual database schema to determine what tables need to be created and what
+ * columns need to be added to existing tables.
+ *
+ * The comparison process follows these steps:
+ * 1. Load the expected schema from configuration
+ * 2. Compare it with tables in the actual database
+ * 3. Identify tables that don't exist but should be created
+ * 4. Identify columns that need to be added to existing tables
+ *
+ * @remarks
+ * This is a core part of the migration system and is used by the main migration
+ * generator to determine what database changes are needed.
+ *
+ * @module migration/schema-comparison
+ */
+import type { C15TOptions } from '../../types';
+import type { KyselyDatabaseType } from '../adapters/kysely-adapter/types';
+import type { ColumnsToAdd, TableToCreate } from './types';
+/**
+ * Analyzes schema differences between the expected schema and actual database
+ *
+ * This function compares the schema defined in the application with the
+ * actual database structure to determine what changes need to be made.
+ *
+ * @param config - c15t configuration containing the schema definition
+ * @param tableMetadata - Database table metadata from introspection, containing
+ *                        information about existing tables and columns
+ * @param dbType - The database type (postgres, mysql, sqlite, mssql) which affects
+ *                 how types are compared and mapped
+ *
+ * @returns An object containing tables to be created and columns to be added
+ *
+ * @example
+ * ```typescript
+ * const changes = analyzeSchemaChanges(
+ *   appConfig,
+ *   databaseMetadata,
+ *   'postgres'
+ * );
+ *
+ * console.log(`Need to create ${changes.toBeCreated.length} tables`);
+ * console.log(`Need to add columns to ${changes.toBeAdded.length} tables`);
+ * ```
+ */
+export declare function analyzeSchemaChanges(config: C15TOptions, tableMetadata: TableMetadata[], dbType: KyselyDatabaseType): {
+    toBeCreated: TableToCreate[];
+    toBeAdded: ColumnsToAdd[];
+};
+//# sourceMappingURL=schema-comparison.d.ts.map

package/dist/db/migration/schema-comparison.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-comparison.d.ts","sourceRoot":"","sources":["../../../src/db/migration/schema-comparison.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAE5C;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AAI3E,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,oBAAoB,CACnC,MAAM,EAAE,WAAW,EACnB,aAAa,EAAE,aAAa,EAAE,EAC9B,MAAM,EAAE,kBAAkB,GACxB;IAAE,WAAW,EAAE,aAAa,EAAE,CAAC;IAAC,SAAS,EAAE,YAAY,EAAE,CAAA;CAAE,CAwB7D"}

package/dist/db/migration/type-mapping.d.ts

@@ -0,0 +1,86 @@
+import type { Field, FieldType } from '../core/fields';
+/**
+ * Database type mapping functionality
+ *
+ * This module handles mapping between abstract field types and
+ * database-specific column types. It provides utilities for:
+ * 1. Converting between c15t field types and database-specific types
+ * 2. Checking type compatibility across different databases
+ * 3. Determining appropriate database types based on field attributes
+ *
+ * @module migration/type-mapping
+ */
+import type { KyselyDatabaseType } from '../adapters/kysely-adapter/types';
+/**
+ * Determines MySQL string type based on field attributes
+ *
+ * @param field - Field attributes including unique and references properties
+ * @returns The appropriate MySQL type for the string field
+ *
+ * @example
+ * ```typescript
+ * // Returns 'varchar(255)' for unique fields
+ * getMySqlStringType({ type: 'string', unique: true });
+ *
+ * // Returns 'varchar(36)' for reference fields
+ * getMySqlStringType({ type: 'string', references: 'subjects' });
+ *
+ * // Returns 'text' for regular string fields
+ * getMySqlStringType({ type: 'string' });
+ * ```
+ */
+export declare function getMySqlStringType(field: Field): string;
+/**
+ * Checks if a database column type matches the expected field type
+ *
+ * @param columnDataType - The actual column type in the database
+ * @param fieldType - The expected field type from c15t
+ * @param dbType - The database type (postgres, mysql, etc.)
+ * @returns True if types match, false otherwise
+ *
+ * @remarks
+ * This function handles type compatibility across different databases,
+ * accounting for the fact that the same logical type may have different
+ * names in different database systems.
+ *
+ * Array types (string[] and number[]) are treated specially and matched
+ * against JSON-compatible column types.
+ *
+ * @example
+ * ```typescript
+ * // Returns true because 'text' is compatible with 'string' in PostgreSQL
+ * matchType('text', 'string', 'postgres');
+ *
+ * // Returns true because 'jsonb' is compatible with array types
+ * matchType('jsonb', 'string[]', 'postgres');
+ * ```
+ */
+export declare function matchType(columnDataType: string, fieldType: FieldType, dbType: KyselyDatabaseType): boolean;
+/**
+ * Gets the appropriate database type for a field
+ *
+ * @param field - Field attributes including type and other properties
+ * @param dbType - Database type to get the appropriate type for
+ * @returns The appropriate database-specific type
+ *
+ * @remarks
+ * This function determines the most appropriate database type for a given field,
+ * taking into account:
+ * - The field's base type (string, number, boolean, etc.)
+ * - Special attributes (unique, references, bigint)
+ * - Database-specific requirements and best practices
+ *
+ * @example
+ * ```typescript
+ * // Returns 'text' for a regular string field in SQLite
+ * getType({ type: 'string' }, 'sqlite');
+ *
+ * // Returns 'jsonb' for a JSON field in PostgreSQL
+ * getType({ type: 'json' }, 'postgres');
+ *
+ * // Returns 'bigint' for a number field with bigint flag
+ * getType({ type: 'number', bigint: true }, 'mysql');
+ * ```
+ */
+export declare function getType(field: Field, dbType?: KyselyDatabaseType): string;
+//# sourceMappingURL=type-mapping.d.ts.map

package/dist/db/migration/type-mapping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-mapping.d.ts","sourceRoot":"","sources":["../../../src/db/migration/type-mapping.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AACzD;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AAqF3E;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAQvD;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,SAAS,CACxB,cAAc,EAAE,MAAM,EACtB,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,kBAAkB,GACxB,OAAO,CAUT;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,GAAE,kBAA6B,UA8D1E"}

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

@@ -0,0 +1,37 @@
+/**
+ * Types used throughout the migration system
+ *
+ * @module migration/types
+ */
+import type { AlterTableColumnAlteringBuilder, CreateTableBuilder } from 'kysely';
+import type { Field } from '../core/fields';
+/**
+ * Type representing a table to be created during migration
+ */
+export interface TableToCreate {
+    table: string;
+    fields: Record<string, Field>;
+    order: number;
+}
+/**
+ * Type representing table columns to be added during migration
+ */
+export interface ColumnsToAdd {
+    table: string;
+    fields: Record<string, Field>;
+    order: number;
+}
+/**
+ * Type for migration operations
+ */
+export type MigrationOperation = AlterTableColumnAlteringBuilder | CreateTableBuilder<string, string>;
+/**
+ * Result of migration generation
+ */
+export interface MigrationResult {
+    toBeCreated: TableToCreate[];
+    toBeAdded: ColumnsToAdd[];
+    runMigrations: () => Promise<void>;
+    compileMigrations: () => Promise<string>;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/db/migration/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACX,+BAA+B,EAC/B,kBAAkB,EAClB,MAAM,QAAQ,CAAC;AAChB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAE9C;;GAEG;AACH,MAAM,WAAW,aAAa;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAC9B,KAAK,EAAE,MAAM,CAAC;CACd;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAC9B,KAAK,EAAE,MAAM,CAAC;CACd;AAED;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAC3B,+BAA+B,GAC/B,kBAAkB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAEtC;;GAEG;AACH,MAAM,WAAW,eAAe;IAC/B,WAAW,EAAE,aAAa,EAAE,CAAC;IAC7B,SAAS,EAAE,YAAY,EAAE,CAAC;IAC1B,aAAa,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACnC,iBAAiB,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;CACzC"}

package/dist/db/schema/audit-log/index.d.ts

@@ -0,0 +1,4 @@
+export * from './registry';
+export * from './schema';
+export * from './table';
+//# sourceMappingURL=index.d.ts.map

package/dist/db/schema/audit-log/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/db/schema/audit-log/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC"}

package/dist/db/schema/audit-log/registry.d.ts

@@ -0,0 +1,128 @@
+import type { GenericEndpointContext } from '../../../types';
+import type { RegistryContext } from '../../../types/context';
+import type { AuditLog } from './schema';
+/**
+ * Creates and returns a set of consent audit log adapter methods to interact with the database.
+ * These methods provide a consistent interface for creating and querying audit logs
+ * while applying hooks and enforcing data validation rules.
+ *
+ * @param adapter - The database adapter used for direct database operations
+ * @param ctx - The context object containing the database adapter, hooks, and options
+ * @returns An object containing type-safe consent audit log operations
+ *
+ * @example
+ * ```typescript
+ * const auditLogAdapter = createAuditLogAdapter({
+ *   adapter: databaseAdapter,
+ *   createWithHooks,
+ *   options: c15tOptions
+ * });
+ *
+ * // Create a new audit log entry
+ * const log = await auditLogAdapter.createAuditLog({
+ *   entityType: 'consent',
+ *   entityId: 'cns_hadt8w7nngm7xmx2bn',
+ *   actionType: 'update',
+ *   subjectId: 'sub_x1pftyoufsm7xgo1kv',
+ *   changes: { status: { from: 'active', to: 'withdrawn' } }
+ * });
+ * ```
+ */
+export declare function auditLogRegistry({ adapter, ...ctx }: RegistryContext): {
+    /**
+     * Creates a new consent audit log entry in the database.
+     * Automatically sets creation timestamp and applies any
+     * configured hooks during the creation process.
+     *
+     * @param auditLog - Audit log data to create (without id and timestamp)
+     * @param context - Optional endpoint context for hooks
+     * @returns The created audit log entry with all fields populated
+     * @throws May throw an error if hooks prevent creation or if database operations fail
+     */
+    createAuditLog: (auditLog: Omit<AuditLog, "id" | "createdAt"> & Partial<AuditLog>, context?: GenericEndpointContext) => Promise<{
+        id: string;
+        entityType: string;
+        entityId: string;
+        actionType: string;
+        createdAt: Date;
+        subjectId?: string | undefined;
+        ipAddress?: string | undefined;
+        userAgent?: string | undefined;
+        changes?: Record<string, unknown> | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }>;
+    /**
+     * Finds all audit log entries matching specified filters.
+     * Returns logs with processed output fields according to the schema configuration.
+     *
+     * @param entityType - Optional entity type to filter logs (e.g., 'consent', 'subject')
+     * @param entityId - Optional entity ID to filter logs
+     * @param actionType - Optional action type to filter logs (e.g., 'create', 'update')
+     * @param limit - Optional maximum number of logs to return
+     * @param offset - Optional number of logs to skip for pagination
+     * @returns Array of audit log entries matching the criteria
+     */
+    findAuditLogs: (entityType?: string, entityId?: string, actionType?: string, limit?: number, offset?: number) => Promise<{
+        id: string;
+        entityType: string;
+        entityId: string;
+        actionType: string;
+        createdAt: Date;
+        subjectId?: string | undefined;
+        ipAddress?: string | undefined;
+        userAgent?: string | undefined;
+        changes?: Record<string, unknown> | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }[]>;
+    /**
+     * Finds a specific audit log entry by its ID.
+     * Returns the log with processed output fields according to the schema configuration.
+     *
+     * @param auditLogId - The unique identifier of the audit log entry
+     * @returns The audit log entry if found, null otherwise
+     */
+    findAuditLogById: (auditLogId: string) => Promise<{
+        id: string;
+        entityType: string;
+        entityId: string;
+        actionType: string;
+        createdAt: Date;
+        subjectId?: string | undefined;
+        ipAddress?: string | undefined;
+        userAgent?: string | undefined;
+        changes?: Record<string, unknown> | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    } | null>;
+    /**
+     * Finds all audit log entries for a specific entity.
+     * Returns logs with processed output fields according to the schema configuration.
+     *
+     * @param entityType - The type of entity (e.g., 'consent', 'subject')
+     * @param entityId - The unique identifier of the entity
+     * @param limit - Optional maximum number of logs to return
+     * @returns Array of audit log entries for the specified entity
+     */
+    findAuditLogsByEntity: (entityType: string, entityId: string, limit?: number) => Promise<{
+        id: string;
+        entityType: string;
+        entityId: string;
+        actionType: string;
+        createdAt: Date;
+        subjectId?: string | undefined;
+        ipAddress?: string | undefined;
+        userAgent?: string | undefined;
+        changes?: Record<string, unknown> | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }[]>;
+    /**
+     * Counts the total number of audit log entries matching specified filters.
+     * Useful for pagination and reporting.
+     *
+     * @param entityType - Optional entity type to filter logs
+     * @param entityId - Optional entity ID to filter logs
+     * @param actionType - Optional action type to filter logs
+     * @returns The total count of matching audit log entries
+     */
+    countAuditLogs: (entityType?: string, entityId?: string, actionType?: string) => Promise<number>;
+};
+//# sourceMappingURL=registry.d.ts.map

package/dist/db/schema/audit-log/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../src/db/schema/audit-log/registry.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACzC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,OAAO,EAAE,GAAG,GAAG,EAAE,EAAE,eAAe;IAInE;;;;;;;;;OASG;+BAEQ,IAAI,CAAC,QAAQ,EAAE,IAAI,GAAG,WAAW,CAAC,GAAG,OAAO,CAAC,QAAQ,CAAC,YACtD,sBAAsB;;;;;;;;;;;;IAqBjC;;;;;;;;;;OAUG;iCAEW,MAAM,aACR,MAAM,eACJ,MAAM,UACX,MAAM,WACL,MAAM;;;;;;;;;;;;IAyChB;;;;;;OAMG;mCACkC,MAAM;;;;;;;;;;;;IAa3C;;;;;;;;OAQG;wCAEU,MAAM,YACR,MAAM,UACR,MAAM;;;;;;;;;;;;IAyBf;;;;;;;;OAQG;kCAEW,MAAM,aACR,MAAM,eACJ,MAAM;EA+BrB"}

package/dist/db/schema/audit-log/schema.d.ts

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+/**
+ * Zod schema for validating consent audit log entities.
+ *
+ * This defines the structure and validation rules for audit log entries:
+ * - Required fields: entityType, entityId, actionType
+ * - Optional fields: subjectId, ipAddress, changes, metadata
+ * - Default current date/time for creation timestamp
+ *
+ * @example
+ * ```typescript
+ * const auditLogData = {
+ *   id: 'log_w5qufx2a66m7xkn3ty',
+ *   entityType: 'consent',
+ *   entityId: 'cns_hadt8w7nngm7xmx2bn',
+ *   actionType: 'update',
+ *   subjectId: 'sub_x1pftyoufsm7xgo1kv',
+ *   changes: { status: { from: 'active', to: 'withdrawn' } }
+ * };
+ *
+ * // Validate and parse the audit log data
+ * const validAuditLog = auditLogSchema.parse(auditLogData);
+ * ```
+ */
+export declare const auditLogSchema: z.ZodObject<{
+    id: z.ZodString;
+    entityType: z.ZodString;
+    entityId: z.ZodString;
+    actionType: z.ZodString;
+    subjectId: z.ZodOptional<z.ZodString>;
+    ipAddress: z.ZodOptional<z.ZodString>;
+    userAgent: z.ZodOptional<z.ZodString>;
+    changes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    createdAt: z.ZodDefault<z.ZodDate>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    entityType: string;
+    entityId: string;
+    actionType: string;
+    createdAt: Date;
+    subjectId?: string | undefined;
+    ipAddress?: string | undefined;
+    userAgent?: string | undefined;
+    changes?: Record<string, unknown> | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    id: string;
+    entityType: string;
+    entityId: string;
+    actionType: string;
+    subjectId?: string | undefined;
+    ipAddress?: string | undefined;
+    userAgent?: string | undefined;
+    changes?: Record<string, unknown> | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    createdAt?: Date | undefined;
+}>;
+/**
+ * Type definition for AuditLog
+ *
+ * This type represents the structure of a consent audit log entry
+ * as defined by the auditLogSchema. It includes all fields
+ * that are part of the audit log entity.
+ */
+export type AuditLog = z.infer<typeof auditLogSchema>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/db/schema/audit-log/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/db/schema/audit-log/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWzB,CAAC;AAEH;;;;;;GAMG;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/dist/db/schema/audit-log/table.d.ts

@@ -0,0 +1,175 @@
+import { type Field } from '../../core/fields';
+import type { C15TOptions } from '../../../types';
+/**
+ * Generates the database table configuration for the consent audit log entity.
+ *
+ * This function creates a schema definition that includes all standard audit log fields
+ * and any additional fields from plugins or configuration. The resulting schema is used
+ * for database migrations, schema validation, and query building.
+ *
+ * @param options - C15T configuration options that may contain audit log table customizations
+ * @param auditLogFields - Additional fields from plugins to include in the audit log table
+ * @returns A complete table schema definition with fields, model name, and metadata
+ *
+ * @example
+ * ```typescript
+ * const auditLogTableSchema = getAuditLogTable(c15tOptions);
+ * // Use the schema for migrations or data access
+ * const migrationPlans = generateMigrations(auditLogTableSchema);
+ * ```
+ */
+export declare function getAuditLogTable(options: C15TOptions, auditLogFields?: Record<string, Field>): {
+    /**
+     * The name of the audit log table in the database, configurable through options
+     */
+    entityName: string;
+    /**
+     * The ID prefix for the audit log table
+     * Used to generate unique prefixed IDs
+     */
+    entityPrefix: string;
+    /**
+     * The schema for the audit log table
+     */
+    schema: import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        entityType: import("zod").ZodString;
+        entityId: import("zod").ZodString;
+        actionType: import("zod").ZodString;
+        subjectId: import("zod").ZodOptional<import("zod").ZodString>;
+        ipAddress: import("zod").ZodOptional<import("zod").ZodString>;
+        userAgent: import("zod").ZodOptional<import("zod").ZodString>;
+        changes: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        createdAt: import("zod").ZodDefault<import("zod").ZodDate>;
+    }, "strip", import("zod").ZodTypeAny, {
+        id: string;
+        entityType: string;
+        entityId: string;
+        actionType: string;
+        createdAt: Date;
+        subjectId?: string | undefined;
+        ipAddress?: string | undefined;
+        userAgent?: string | undefined;
+        changes?: Record<string, unknown> | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }, {
+        id: string;
+        entityType: string;
+        entityId: string;
+        actionType: string;
+        subjectId?: string | undefined;
+        ipAddress?: string | undefined;
+        userAgent?: string | undefined;
+        changes?: Record<string, unknown> | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        createdAt?: Date | undefined;
+    }>;
+    /**
+     * Field definitions for the consent audit log table
+     */
+    fields: {
+        /**
+         * Type of entity this audit log entry is about (e.g., 'consent', 'subject', 'consentPurpose')
+         */
+        entityType: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * ID of the entity this audit log entry is about
+         */
+        entityId: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * Type of action that was performed on the entity
+         * Common values: 'create', 'update', 'delete', 'view'
+         */
+        actionType: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * Optional ID of the subject who performed the action
+         */
+        subjectId: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+            references: {
+                model: string;
+                field: string;
+            };
+        };
+        /**
+         * IP address from which the action was performed
+         */
+        ipAddress: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * Subject agent (browser/device) from which the action was performed
+         */
+        userAgent: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * Detailed changes made to the entity
+         * For updates, this typically contains before/after values
+         */
+        changes: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * Additional metadata about the action
+         */
+        metadata: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * When the audit log entry was created
+         * Automatically set to current time by default
+         */
+        createdAt: {
+            type: string;
+            defaultValue: () => Date;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * Timezone where the audit event occurred
+         */
+        eventTimezone: {
+            type: string;
+            required: boolean;
+            defaultValue: "UTC";
+            fieldName: string;
+        };
+    };
+    /**
+     * Add indexes for better query performance
+     */
+    indexes: {
+        name: string;
+        fields: string[];
+    }[];
+    /**
+     * Execution order during migrations (lower numbers run first)
+     * Audit log table needs to be created after the subject table it references
+     */
+    order: number;
+};
+//# sourceMappingURL=table.d.ts.map

package/dist/db/schema/audit-log/table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../../../src/db/schema/audit-log/table.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,KAAK,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAChE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAG3C;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAC/B,OAAO,EAAE,WAAW,EACpB,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;IAMrC;;OAEG;;IAGH;;;OAGG;;IAGH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGH;;OAEG;;QAEF;;WAEG;;;;;;QAOH;;WAEG;;;;;;QAOH;;;WAGG;;;;;;QAOH;;WAEG;;;;;;;;;;QAWH;;WAEG;;;;;;QAOH;;WAEG;;;;;;QAOH;;;WAGG;;;;;;QAOH;;WAEG;;;;;;QAOH;;;WAGG;;;;;;;QAQH;;WAEG;;;;;;;;IAeJ;;OAEG;;;;;IAoBH;;;OAGG;;EAGJ"}

package/dist/db/schema/audit-log/types.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Audit Log Entity Type Definitions
+ *
+ * This module contains type definitions specific to the audit log entity.
+ */
+import type { BaseEntityConfig } from '../types';
+/**
+ * Audit log entity configuration
+ * @default {entityName: "auditLog", entityPrefix: "log"}
+ *
+ * These defaults are applied when creating an audit log entity if not explicitly specified.
+ * See the entity creation utilities for implementation details.
+ */
+export interface AuditLogEntityConfig extends BaseEntityConfig {
+    fields?: Record<string, string> & {
+        id?: string;
+        timestamp: string;
+        action: string;
+        subjectId?: string;
+        resourceType: string;
+        resourceId?: string;
+        actor?: string;
+        changes?: string;
+        deviceInfo?: string;
+        ipAddress?: string;
+        createdAt?: string;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/db/schema/audit-log/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/db/schema/audit-log/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD;;;;;;GAMG;AACH,MAAM,WAAW,oBAAqB,SAAQ,gBAAgB;IAC7D,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG;QACjC,EAAE,CAAC,EAAE,MAAM,CAAC;QACZ,SAAS,EAAE,MAAM,CAAC;QAClB,MAAM,EAAE,MAAM,CAAC;QACf,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,YAAY,EAAE,MAAM,CAAC;QACrB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC;CACF"}