@c15t/backend 0.0.1-rc.10

package/dist/db/schema/consent-purpose/table.d.ts

@@ -0,0 +1,161 @@
+import type { Field } from '../../core/fields';
+import type { C15TOptions } from '../../../types';
+/**
+ * Generates the database table configuration for the consent consentPurpose entity.
+ *
+ * This function creates a schema definition that includes all standard consent consentPurpose 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 consentPurpose table customizations
+ * @param purposeFields - Additional fields from plugins to include in the consentPurpose table
+ * @returns A complete table schema definition with fields, model name, and metadata
+ *
+ * @example
+ * ```typescript
+ * const purposeTableSchema = getPurposeTable(c15tOptions);
+ * // Use the schema for migrations or data access
+ * const migrationPlans = generateMigrations(purposeTableSchema);
+ * ```
+ */
+export declare function getPurposeTable(options: C15TOptions, purposeFields?: Record<string, Field>): {
+    /**
+     * The name of the consentPurpose table in the database, configurable through options
+     */
+    entityName: string;
+    /**
+     * The ID prefix for the consentPurpose table
+     * Used to generate unique prefixed IDs for purposes
+     */
+    entityPrefix: string;
+    /**
+     * The schema for the consentPurpose table
+     */
+    schema: import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        code: import("zod").ZodString;
+        name: import("zod").ZodString;
+        description: import("zod").ZodString;
+        isEssential: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        dataCategory: import("zod").ZodOptional<import("zod").ZodString>;
+        legalBasis: import("zod").ZodOptional<import("zod").ZodString>;
+        isActive: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        createdAt: import("zod").ZodDefault<import("zod").ZodDate>;
+        updatedAt: import("zod").ZodDefault<import("zod").ZodDate>;
+    }, "strip", import("zod").ZodTypeAny, {
+        id: string;
+        code: string;
+        createdAt: Date;
+        isActive: boolean;
+        updatedAt: Date;
+        name: string;
+        description: string;
+        isEssential: boolean;
+        dataCategory?: string | undefined;
+        legalBasis?: string | undefined;
+    }, {
+        id: string;
+        code: string;
+        name: string;
+        description: string;
+        createdAt?: Date | undefined;
+        isActive?: boolean | undefined;
+        updatedAt?: Date | undefined;
+        isEssential?: boolean | undefined;
+        dataCategory?: string | undefined;
+        legalBasis?: string | undefined;
+    }>;
+    /**
+     * Field definitions for the consent consentPurpose table
+     */
+    fields: {
+        /**
+         * Unique code for the consentPurpose, used for programmatic identification
+         */
+        code: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * Human-readable name of the consentPurpose
+         */
+        name: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * Detailed description of the consentPurpose, shown to subjects
+         */
+        description: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * Whether this is an essential consentPurpose that doesn't require explicit consent
+         * Default: false
+         */
+        isEssential: {
+            type: string;
+            defaultValue: () => boolean;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * Category of data this consentPurpose processes (e.g., 'personal', 'profile')
+         * Optional field
+         */
+        dataCategory: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * Legal basis for data processing (e.g., 'consent', 'legitimate interest')
+         * Optional field
+         */
+        legalBasis: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * Whether this consentPurpose is currently active
+         * Default: true
+         */
+        isActive: {
+            type: string;
+            defaultValue: boolean;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * When the consentPurpose record was created
+         * Automatically set to current time by default
+         */
+        createdAt: {
+            type: string;
+            defaultValue: () => Date;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * When the consentPurpose record was last updated
+         * Automatically updated on each modification
+         */
+        updatedAt: {
+            type: string;
+            defaultValue: () => Date;
+            required: boolean;
+            fieldName: string;
+        };
+    };
+    /**
+     * Execution order during migrations (lower numbers run first)
+     * ConsentPurpose table needs to be created relatively early as other tables reference it
+     */
+    order: number;
+};
+//# sourceMappingURL=table.d.ts.map

package/dist/db/schema/consent-purpose/table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../../../src/db/schema/consent-purpose/table.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAG3C;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,CAC9B,OAAO,EAAE,WAAW,EACpB,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;IAKpC;;OAEG;;IAGH;;;OAGG;;IAGH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGH;;OAEG;;QAEF;;WAEG;;;;;;QAOH;;WAEG;;;;;;QAOH;;WAEG;;;;;;QAOH;;;WAGG;;;;;;;QAQH;;;WAGG;;;;;;QAOH;;;WAGG;;;;;;QAOH;;;WAGG;;;;;;;QAQH;;;WAGG;;;;;;;QAQH;;;WAGG;;;;;;;;IAeJ;;;OAGG;;EAGJ"}

package/dist/db/schema/consent-purpose/types.d.ts

@@ -0,0 +1,16 @@
+import type { ActiveEntityConfig } from '../types';
+/**
+ * ConsentPurpose entity configuration
+ * @default entityName: "consentPurpose", entityPrefix: "pur"
+ */
+export interface ConsentPurposeEntityConfig extends ActiveEntityConfig {
+    fields?: Record<string, string> & {
+        id?: string;
+        name?: string;
+        description?: string;
+        isActive?: string;
+        createdAt?: string;
+        updatedAt?: string;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/db/schema/consent-purpose/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/db/schema/consent-purpose/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAEnD;;;GAGG;AACH,MAAM,WAAW,0BAA2B,SAAQ,kBAAkB;IACrE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG;QACjC,EAAE,CAAC,EAAE,MAAM,CAAC;QACZ,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC;CACF"}

package/dist/db/schema/consent-purpose-junction/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/consent-purpose-junction/index.d.ts.map

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

package/dist/db/schema/consent-purpose-junction/registry.d.ts

@@ -0,0 +1,109 @@
+import type { GenericEndpointContext, RegistryContext } from '../../../types';
+import type { PurposeJunction } from './schema';
+/**
+ * Creates and returns a set of consent-purpose junction adapter methods to interact with the database.
+ * These methods provide a consistent interface for creating, finding, and managing
+ * relationships between consents and purposes 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-purpose junction operations
+ *
+ * @example
+ * ```typescript
+ * const junctionAdapter = createConsentPurposeJunctionAdapter(
+ *   databaseAdapter,
+ *   createWithHooks,
+ *   updateWithHooks,
+ *   c15tOptions
+ * );
+ *
+ * // Create a new junction record
+ * const junction = await junctionAdapter.createConsentPurposeJunction({
+ *   consentId: 'cns_hadt8w7nngm7xmx2bn',
+ *   purposeId: 'pol_tioiyf19tbkm7xn5vpx',
+ *   status: 'active'
+ * });
+ * ```
+ */
+export declare function consentPurposeJunctionRegistry({ adapter, ...ctx }: RegistryContext): {
+    /**
+     * Creates a new consent-purpose junction record in the database.
+     * Automatically sets creation timestamp and applies any
+     * configured hooks during the creation process.
+     *
+     * @param junction - Junction data to create (without id and timestamp)
+     * @param context - Optional endpoint context for hooks
+     * @returns The created junction record with all fields populated
+     * @throws May throw an error if hooks prevent creation or if database operations fail
+     */
+    createConsentPurposeJunction: (junction: Omit<PurposeJunction, "id" | "createdAt" | "status"> & Partial<PurposeJunction>, context?: GenericEndpointContext) => Promise<{
+        id: string;
+        status: "active" | "withdrawn";
+        createdAt: Date;
+        consentId: string;
+        updatedAt: Date;
+        consentPurposeId: string;
+        metadata?: Record<string, string | number | boolean> | undefined;
+    }>;
+    /**
+     * Finds all junction records for a specific consent.
+     * Returns junctions with processed output fields according to the schema configuration.
+     *
+     * @param consentId - The consent ID to find purposes for
+     * @returns Array of junction records associated with the consent
+     */
+    findConsentPurposesByConsentId: (consentId: string) => Promise<{
+        id: string;
+        status: "active" | "withdrawn";
+        createdAt: Date;
+        consentId: string;
+        updatedAt: Date;
+        consentPurposeId: string;
+        metadata?: Record<string, string | number | boolean> | undefined;
+    }[]>;
+    /**
+     * Finds all junction records for a specific consentPurpose.
+     * Returns junctions with processed output fields according to the schema configuration.
+     *
+     * @param purposeId - The consentPurpose ID to find consents for
+     * @returns Array of junction records associated with the consentPurpose
+     */
+    findConsentPurposesByPurposeId: (purposeId: string) => Promise<{
+        id: string;
+        status: "active" | "withdrawn";
+        createdAt: Date;
+        consentId: string;
+        updatedAt: Date;
+        consentPurposeId: string;
+        metadata?: Record<string, string | number | boolean> | undefined;
+    }[]>;
+    /**
+     * Updates a junction record's status.
+     * Applies any configured hooks during the update process and
+     * processes the output according to schema configuration.
+     *
+     * @param junctionId - The unique identifier of the junction to update
+     * @param status - The new status value ('active' or 'withdrawn')
+     * @param context - Optional endpoint context for hooks
+     * @returns The updated junction if successful, null if not found or hooks prevented update
+     */
+    updateConsentPurposeJunction: (junctionId: string, status: "active" | "withdrawn", context?: GenericEndpointContext) => Promise<{
+        id: string;
+        status: "active" | "withdrawn";
+        createdAt: Date;
+        consentId: string;
+        updatedAt: Date;
+        consentPurposeId: string;
+        metadata?: Record<string, string | number | boolean> | undefined;
+    } | null>;
+    /**
+     * Deletes all junction records for a specific consent.
+     * This effectively removes all consentPurpose connections for the consent.
+     *
+     * @param consentId - The ID of the consent to remove all consentPurpose connections for
+     * @returns True if successful, false otherwise
+     */
+    deleteConsentPurposeJunctionsByConsentId: (consentId: string) => Promise<boolean>;
+};
+//# sourceMappingURL=registry.d.ts.map

package/dist/db/schema/consent-purpose-junction/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../src/db/schema/consent-purpose-junction/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AACvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAKhD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,8BAA8B,CAAC,EAC9C,OAAO,EACP,GAAG,GAAG,EACN,EAAE,eAAe;IAGhB;;;;;;;;;OASG;6CAEQ,IAAI,CAAC,eAAe,EAAE,IAAI,GAAG,WAAW,GAAG,QAAQ,CAAC,GAC7D,OAAO,CAAC,eAAe,CAAC,YACf,sBAAsB;;;;;;;;;IAuBjC;;;;;;OAMG;gDAC+C,MAAM;;;;;;;;;IAoBxD;;;;;;OAMG;gDAC+C,MAAM;;;;;;;;;IAoBxD;;;;;;;;;OASG;+CAEU,MAAM,UACV,QAAQ,GAAG,WAAW,YACpB,sBAAsB;;;;;;;;;IAsBjC;;;;;;OAMG;0DACyD,MAAM;EAkBnE"}

package/dist/db/schema/consent-purpose-junction/schema.d.ts

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+/**
+ * Zod schema for validating consent-purpose junction entities.
+ *
+ * This defines the structure and validation rules for junction records:
+ * - Required fields: consentId, purposeId
+ * - Default value of 'active' for status
+ * - Default current date/time for creation and update timestamps
+ * - Default current date/time for update timestamp
+ *
+ * @example
+ * ```typescript
+ * const junctionData = {
+ *   id: 'pjx_w5qufx2a66m7xkn3ty',
+ *   consentId: 'cns_hadt8w7nngm7xmx2bn',
+ *   purposeId: 'pur_e8zyhgozr3im7xj59it',
+ *   status: 'active'
+ * };
+ *
+ * // Validate and parse the junction data
+ * const validJunction = consentPurposeJunctionSchema.parse(junctionData);
+ * ```
+ */
+export declare const consentPurposeJunctionSchema: z.ZodObject<{
+    id: z.ZodString;
+    consentId: z.ZodString;
+    consentPurposeId: z.ZodString;
+    status: z.ZodDefault<z.ZodEnum<["active", "withdrawn"]>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+    createdAt: z.ZodDefault<z.ZodDate>;
+    updatedAt: z.ZodDefault<z.ZodDate>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    status: "active" | "withdrawn";
+    createdAt: Date;
+    consentId: string;
+    updatedAt: Date;
+    consentPurposeId: string;
+    metadata?: Record<string, string | number | boolean> | undefined;
+}, {
+    id: string;
+    consentId: string;
+    consentPurposeId: string;
+    status?: "active" | "withdrawn" | undefined;
+    metadata?: Record<string, string | number | boolean> | undefined;
+    createdAt?: Date | undefined;
+    updatedAt?: Date | undefined;
+}>;
+/**
+ * Type definition for PurposeJunction
+ *
+ * This type represents the structure of a consent-purpose junction record
+ * as defined by the consentPurposeJunctionSchema. It includes all fields
+ * that are part of the junction entity.
+ */
+export type PurposeJunction = z.infer<typeof consentPurposeJunctionSchema>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/db/schema/consent-purpose-junction/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/db/schema/consent-purpose-junction/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;EAevC,CAAC;AAEH;;;;;;GAMG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC"}

package/dist/db/schema/consent-purpose-junction/table.d.ts

@@ -0,0 +1,138 @@
+import type { Field } from '../../core/fields';
+import type { C15TOptions } from '../../../types';
+/**
+ * Generates the database table configuration for the consent-purpose junction entity.
+ *
+ * This function creates a schema definition that implements a many-to-many relationship
+ * between consents and purposes. The resulting schema is used for database migrations,
+ * schema validation, and query building.
+ *
+ * @param options - C15T configuration options that may contain junction table customizations
+ * @param junctionFields - Additional fields from plugins to include in the junction table
+ * @returns A complete table schema definition with fields, model name, and metadata
+ *
+ * @example
+ * ```typescript
+ * const junctionTableSchema = getPurposeJunctionTable(c15tOptions);
+ * // Use the schema for migrations or data access
+ * const migrationPlans = generateMigrations(junctionTableSchema);
+ * ```
+ */
+export declare function getPurposeJunctionTable(options: C15TOptions, junctionFields?: Record<string, Field>): {
+    /**
+     * The name of the junction table in the database, configurable through options
+     */
+    entityName: string;
+    /**
+     * The ID prefix for the consentPurpose junction table
+     * Used to generate unique prefixed IDs for consentPurpose junctions
+     */
+    entityPrefix: string;
+    /**
+     * The schema for the consentPurpose junction table
+     */
+    schema: import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        consentId: import("zod").ZodString;
+        consentPurposeId: import("zod").ZodString;
+        status: import("zod").ZodDefault<import("zod").ZodEnum<["active", "withdrawn"]>>;
+        metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean]>>>;
+        createdAt: import("zod").ZodDefault<import("zod").ZodDate>;
+        updatedAt: import("zod").ZodDefault<import("zod").ZodDate>;
+    }, "strip", import("zod").ZodTypeAny, {
+        id: string;
+        status: "active" | "withdrawn";
+        createdAt: Date;
+        consentId: string;
+        updatedAt: Date;
+        consentPurposeId: string;
+        metadata?: Record<string, string | number | boolean> | undefined;
+    }, {
+        id: string;
+        consentId: string;
+        consentPurposeId: string;
+        status?: "active" | "withdrawn" | undefined;
+        metadata?: Record<string, string | number | boolean> | undefined;
+        createdAt?: Date | undefined;
+        updatedAt?: Date | undefined;
+    }>;
+    /**
+     * Field definitions for the consent-purpose junction table
+     */
+    fields: {
+        /**
+         * Reference to the consent record this junction is associated with
+         */
+        consentId: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+            references: {
+                model: string;
+                field: string;
+            };
+        };
+        /**
+         * Reference to the consentPurpose record this junction is associated with
+         */
+        purposeId: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+            references: {
+                model: string;
+                field: string;
+            };
+        };
+        /**
+         * Status of this specific consent-purpose relationship
+         * Default: 'active'
+         */
+        status: {
+            type: string;
+            defaultValue: () => string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * Additional metadata about this specific consent-purpose relationship
+         */
+        metadata: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * When the junction record was created
+         * Automatically set to current time by default
+         */
+        createdAt: {
+            type: string;
+            defaultValue: () => Date;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * When the junction record was last updated
+         * Optional, set during updates
+         */
+        updatedAt: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+    };
+    /**
+     * Add unique constraint to ensure a consentPurpose can only be associated with a consent once
+     */
+    uniqueConstraints: {
+        name: string;
+        fields: string[];
+    }[];
+    /**
+     * Execution order during migrations (lower numbers run first)
+     * Junction table needs to be created after the consent and consentPurpose tables it references
+     */
+    order: number;
+};
+//# sourceMappingURL=table.d.ts.map

package/dist/db/schema/consent-purpose-junction/table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../../../src/db/schema/consent-purpose-junction/table.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAG3C;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,uBAAuB,CACtC,OAAO,EAAE,WAAW,EACpB,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;IAOrC;;OAEG;;IAGH;;;OAGG;;IAGH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;IAGH;;OAEG;;QAEF;;WAEG;;;;;;;;;;QAWH;;WAEG;;;;;;;;;;QAWH;;;WAGG;;;;;;;QAQH;;WAEG;;;;;;QAOH;;;WAGG;;;;;;;QAQH;;;WAGG;;;;;;;IAcJ;;OAEG;;;;;IAQH;;;OAGG;;EAGJ"}

package/dist/db/schema/consent-purpose-junction/types.d.ts

@@ -0,0 +1,14 @@
+import type { BaseEntityConfig } from '../types';
+/**
+ * ConsentPurpose junction entity configuration
+ * @default entityName: "consentPurposeJunction", entityPrefix: "pjx"
+ */
+export interface ConsentPurposeJunctionEntityConfig extends BaseEntityConfig {
+    fields?: Record<string, string> & {
+        id?: string;
+        consentId?: string;
+        purposeId?: string;
+        isAccepted?: string;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/db/schema/consent-purpose-junction/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/db/schema/consent-purpose-junction/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD;;;GAGG;AACH,MAAM,WAAW,kCAAmC,SAAQ,gBAAgB;IAC3E,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG;QACjC,EAAE,CAAC,EAAE,MAAM,CAAC;QACZ,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,UAAU,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC;CACF"}

package/dist/db/schema/consent-record/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/consent-record/index.d.ts.map

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

package/dist/db/schema/consent-record/registry.d.ts

@@ -0,0 +1,119 @@
+import type { GenericEndpointContext, RegistryContext } from '../../../types';
+import type { ConsentRecord } from './schema';
+/**
+ * Creates and returns a set of consent record-related adapter methods to interact with the database.
+ * These methods provide a consistent interface for creating and querying consent records
+ * 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 record operations
+ *
+ * @example
+ * ```typescript
+ * const recordAdapter = createRecordAdapter(
+ *   databaseAdapter,
+ *   createWithHooks,
+ *   c15tOptions
+ * );
+ *
+ * // Create a new consent record
+ * const record = await recordAdapter.createConsentRecord({
+ *   subjectId: 'sub_x1pftyoufsm7xgo1kv',
+ *   consentId: 'cns_hadt8w7nngm7xmx2bn',
+ *   actionType: 'given',
+ *   details: { ip: '192.168.1.1', userAgent: 'Mozilla/5.0...' }
+ * });
+ * ```
+ */
+export declare function consentRecordRegistry({ adapter, ...ctx }: RegistryContext): {
+    /**
+     * Creates a new consent record in the database.
+     * Automatically sets creation timestamp and applies any
+     * configured hooks during the creation process.
+     *
+     * @param record - Consent record data to create (without id and timestamp)
+     * @param context - Optional endpoint context for hooks
+     * @returns The created consent record with all fields populated
+     * @throws May throw an error if hooks prevent creation or if database operations fail
+     */
+    createConsentRecord: (record: Omit<ConsentRecord, "id" | "createdAt" | "updatedAt"> & Partial<ConsentRecord>, context?: GenericEndpointContext) => Promise<{
+        id: string;
+        actionType: string;
+        subjectId: string;
+        createdAt: Date;
+        updatedAt: Date;
+        details?: Record<string, unknown> | undefined;
+        consentId?: string | undefined;
+    }>;
+    /**
+     * Finds all consent records matching specified filters.
+     * Returns records with processed output fields according to the schema configuration.
+     *
+     * @param subjectId - Optional subject ID to filter records
+     * @param consentId - Optional consent ID to filter records
+     * @param actionType - Optional action type to filter records
+     * @param limit - Optional maximum number of records to return
+     * @returns Array of consent records matching the criteria
+     */
+    findConsentRecords: (subjectId?: string, consentId?: string, actionType?: string, limit?: number) => Promise<{
+        id: string;
+        actionType: string;
+        subjectId: string;
+        createdAt: Date;
+        updatedAt: Date;
+        details?: Record<string, unknown> | undefined;
+        consentId?: string | undefined;
+    }[]>;
+    /**
+     * Finds a consent record by its unique ID.
+     * Returns the record with processed output fields according to the schema configuration.
+     *
+     * @param recordId - The unique identifier of the consent record
+     * @returns The consent record object if found, null otherwise
+     */
+    findConsentRecordById: (recordId: string) => Promise<{
+        id: string;
+        actionType: string;
+        subjectId: string;
+        createdAt: Date;
+        updatedAt: Date;
+        details?: Record<string, unknown> | undefined;
+        consentId?: string | undefined;
+    } | null>;
+    /**
+     * Finds all consent records for a specific subject.
+     * Returns records with processed output fields according to the schema configuration.
+     *
+     * @param subjectId - The subject ID to find consent records for
+     * @param limit - Optional maximum number of records to return
+     * @returns Array of consent records associated with the subject
+     */
+    findConsentRecordsBySubjectId: (subjectId: string, limit?: number) => Promise<{
+        id: string;
+        actionType: string;
+        subjectId: string;
+        createdAt: Date;
+        updatedAt: Date;
+        details?: Record<string, unknown> | undefined;
+        consentId?: string | undefined;
+    }[]>;
+    /**
+     * Finds all consent records for a specific consent.
+     * Returns records with processed output fields according to the schema configuration.
+     *
+     * @param consentId - The consent ID to find records for
+     * @param limit - Optional maximum number of records to return
+     * @returns Array of consent records associated with the consent
+     */
+    findConsentRecordsByConsentId: (consentId: string, limit?: number) => Promise<{
+        id: string;
+        actionType: string;
+        subjectId: string;
+        createdAt: Date;
+        updatedAt: Date;
+        details?: Record<string, unknown> | undefined;
+        consentId?: string | undefined;
+    }[]>;
+};
+//# sourceMappingURL=registry.d.ts.map

package/dist/db/schema/consent-record/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../src/db/schema/consent-record/registry.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAEvE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,qBAAqB,CAAC,EAAE,OAAO,EAAE,GAAG,GAAG,EAAE,EAAE,eAAe;IAGxE;;;;;;;;;OASG;kCAEM,IAAI,CAAC,aAAa,EAAE,IAAI,GAAG,WAAW,GAAG,WAAW,CAAC,GAC5D,OAAO,CAAC,aAAa,CAAC,YACb,sBAAsB;;;;;;;;;IAsBjC;;;;;;;;;OASG;qCAEU,MAAM,cACN,MAAM,eACL,MAAM,UACX,MAAM;;;;;;;;;IAwCf;;;;;;OAMG;sCACqC,MAAM;;;;;;;;;IAe9C;;;;;;;OAOG;+CAES,MAAM,UACT,MAAM;;;;;;;;;IAqBf;;;;;;;OAOG;+CAES,MAAM,UACT,MAAM;;;;;;;;;EAqBhB"}