@c15t/backend 0.0.1-rc.10

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

@@ -0,0 +1,186 @@
+import type { GenericEndpointContext, RegistryContext } from '../../../types';
+import type { ConsentPolicy } from './schema';
+export interface FindPolicyParams {
+    domainId?: string;
+    version?: string;
+    includeInactive?: boolean;
+}
+/**
+ * Creates and returns a set of consent policy-related adapter methods to interact with the database.
+ * These methods provide a consistent interface for creating, finding, and updating
+ * consent policy 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 policy operations
+ *
+ * @example
+ * ```typescript
+ * const policyAdapter = createConsentPolicyAdapter(
+ *   databaseAdapter,
+ *   createWithHooks,
+ *   updateWithHooks,
+ *   c15tOptions
+ * );
+ *
+ * // Create a new consent policy
+ * const policy = await policyAdapter.createConsentPolicy({
+ *   version: '1.0.0',
+ *   name: 'Privacy Policy 2023',
+ *   effectiveDate: new Date(),
+ *   content: 'Full policy text...',
+ *   contentHash: 'sha256-hash-of-content'
+ * });
+ * ```
+ */
+export declare function policyRegistry({ adapter, ...ctx }: RegistryContext): {
+    /**
+     * Creates a new consent policy record in the database.
+     * Automatically sets creation timestamp and applies any
+     * configured hooks during the creation process.
+     *
+     * @param policy - Policy data to create (without id and timestamp)
+     * @param context - Optional endpoint context for hooks
+     * @returns The created policy with all fields populated
+     * @throws May throw an error if hooks prevent creation or if database operations fail
+     */
+    createConsentPolicy: (policy: Omit<ConsentPolicy, "id" | "createdAt"> & Partial<ConsentPolicy>, context?: GenericEndpointContext) => Promise<{
+        id: string;
+        createdAt: Date;
+        isActive: boolean;
+        updatedAt: Date;
+        version: string;
+        name: string;
+        effectiveDate: Date;
+        content: string;
+        contentHash: string;
+        expirationDate?: Date | null | undefined;
+    }>;
+    findPolicies: (params?: FindPolicyParams) => Promise<{
+        id: string;
+        createdAt: Date;
+        isActive: boolean;
+        updatedAt: Date;
+        version: string;
+        name: string;
+        effectiveDate: Date;
+        content: string;
+        contentHash: string;
+        expirationDate?: Date | null | undefined;
+    }[]>;
+    findPolicy: (domainId: string, version?: string) => Promise<{
+        id: string;
+        createdAt: Date;
+        isActive: boolean;
+        updatedAt: Date;
+        version: string;
+        name: string;
+        effectiveDate: Date;
+        content: string;
+        contentHash: string;
+        expirationDate?: Date | null | undefined;
+    } | null>;
+    /**
+     * Finds all active consent policies.
+     * Returns policies with processed output fields according to the schema configuration.
+     *
+     * @returns Array of active consent policies sorted by effective date
+     */
+    findActiveConsentPolicies: () => Promise<{
+        id: string;
+        createdAt: Date;
+        isActive: boolean;
+        updatedAt: Date;
+        version: string;
+        name: string;
+        effectiveDate: Date;
+        content: string;
+        contentHash: string;
+        expirationDate?: Date | null | undefined;
+    }[]>;
+    /**
+     * Finds a consent policy by its unique ID.
+     * Returns the policy with processed output fields according to the schema configuration.
+     *
+     * @param policyId - The unique identifier of the policy
+     * @returns The policy object if found, null otherwise
+     */
+    findConsentPolicyById: (policyId: string) => Promise<{
+        id: string;
+        createdAt: Date;
+        isActive: boolean;
+        updatedAt: Date;
+        version: string;
+        name: string;
+        effectiveDate: Date;
+        content: string;
+        contentHash: string;
+        expirationDate?: Date | null | undefined;
+    } | null>;
+    /**
+     * Finds a consent policy by its version string.
+     * Returns the policy with processed output fields according to the schema configuration.
+     *
+     * @param version - The version string of the policy
+     * @returns The policy object if found, null otherwise
+     */
+    findConsentPolicyByVersion: (version: string) => Promise<{
+        id: string;
+        createdAt: Date;
+        isActive: boolean;
+        updatedAt: Date;
+        version: string;
+        name: string;
+        effectiveDate: Date;
+        content: string;
+        contentHash: string;
+        expirationDate?: Date | null | undefined;
+    } | null>;
+    /**
+     * Updates an existing consent policy record by ID.
+     * Applies any configured hooks during the update process and
+     * processes the output according to schema configuration.
+     *
+     * @param policyId - The unique identifier of the policy to update
+     * @param data - The fields to update on the policy record
+     * @param context - Optional endpoint context for hooks
+     * @returns The updated policy if successful, null if not found or hooks prevented update
+     */
+    updateConsentPolicy: (policyId: string, data: Partial<ConsentPolicy>, context?: GenericEndpointContext) => Promise<{
+        id: string;
+        createdAt: Date;
+        isActive: boolean;
+        updatedAt: Date;
+        version: string;
+        name: string;
+        effectiveDate: Date;
+        content: string;
+        contentHash: string;
+        expirationDate?: Date | null | undefined;
+    } | null>;
+    /**
+     * Finds the latest active policy or creates a new one if none exists.
+     * Uses a database transaction to prevent race conditions in multi-threaded environments.
+     *
+     * If multiple active policies with the same name exist, returns the most recent one
+     * based on effectiveDate. When creating a new policy, it assigns version '1.0.0'
+     * and generates placeholder content with a SHA-256 hash.
+     *
+     * @param name - The name of the policy to find/create
+     * @returns The policy object
+     * @throws {Error} If the transaction fails to complete
+     */
+    findOrCreatePolicy: (name: string) => Promise<{
+        id: string;
+        createdAt: Date;
+        isActive: boolean;
+        updatedAt: Date;
+        version: string;
+        name: string;
+        effectiveDate: Date;
+        content: string;
+        contentHash: string;
+        expirationDate?: Date | null | undefined;
+    }>;
+};
+//# sourceMappingURL=registry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../src/db/schema/consent-policy/registry.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAEvE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C,MAAM,WAAW,gBAAgB;IAChC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC1B;AAeD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,cAAc,CAAC,EAAE,OAAO,EAAE,GAAG,GAAG,EAAE,EAAE,eAAe;IAGjE;;;;;;;;;OASG;kCAEM,IAAI,CAAC,aAAa,EAAE,IAAI,GAAG,WAAW,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC,YAC9D,sBAAsB;;;;;;;;;;;;4BAoBJ,gBAAgB;;;;;;;;;;;;2BAsChB,MAAM,YAAY,MAAM;;;;;;;;;;;;IAKrD;;;;;OAKG;;;;;;;;;;;;;IAqBH;;;;;;OAMG;sCACqC,MAAM;;;;;;;;;;;;IAe9C;;;;;;OAMG;0CACyC,MAAM;;;;;;;;;;;;IAelD;;;;;;;;;OASG;oCAEQ,MAAM,QACV,OAAO,CAAC,aAAa,CAAC,YAClB,sBAAsB;;;;;;;;;;;;IAsBjC;;;;;;;;;;;OAWG;+BAC8B,MAAM;;;;;;;;;;;;EA+DxC"}

package/dist/db/schema/consent-policy/schema.d.ts

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+/**
+ * Zod schema for validating consent policy entities.
+ *
+ * This defines the structure and validation rules for consent policy records:
+ * - Required fields: version, name, effectiveDate, content, contentHash
+ * - Optional fields: expirationDate
+ * - Default value of true for isActive
+ * - Default current date/time for creation and update timestamps
+ *
+ * @example
+ * ```typescript
+ * const policyData = {
+ *   id: 'pol_w5qufx2a66m7xkn3ty',
+ *   version: '1.0.0',
+ *   name: 'Privacy Policy 2023',
+ *   effectiveDate: new Date(),
+ *   content: 'Full policy text...',
+ *   contentHash: 'sha256-hash-of-content'
+ * };
+ *
+ * // Validate and parse the policy data
+ * const validPolicy = consentPolicySchema.parse(policyData);
+ * ```
+ */
+export declare const consentPolicySchema: z.ZodObject<{
+    id: z.ZodString;
+    version: z.ZodString;
+    name: z.ZodString;
+    effectiveDate: z.ZodDate;
+    expirationDate: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    content: z.ZodString;
+    contentHash: z.ZodString;
+    isActive: z.ZodDefault<z.ZodBoolean>;
+    createdAt: z.ZodDefault<z.ZodDate>;
+    updatedAt: z.ZodDefault<z.ZodDate>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    createdAt: Date;
+    isActive: boolean;
+    updatedAt: Date;
+    version: string;
+    name: string;
+    effectiveDate: Date;
+    content: string;
+    contentHash: string;
+    expirationDate?: Date | null | undefined;
+}, {
+    id: string;
+    version: string;
+    name: string;
+    effectiveDate: Date;
+    content: string;
+    contentHash: string;
+    createdAt?: Date | undefined;
+    isActive?: boolean | undefined;
+    updatedAt?: Date | undefined;
+    expirationDate?: Date | null | undefined;
+}>;
+/**
+ * Type definition for ConsentPolicy
+ *
+ * This type represents the structure of a consent policy record
+ * as defined by the consentPolicySchema. It includes all fields
+ * that are part of the consent policy entity.
+ */
+export type ConsentPolicy = z.infer<typeof consentPolicySchema>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/db/schema/consent-policy/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/db/schema/consent-policy/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAW9B,CAAC;AAEH;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

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

@@ -0,0 +1,147 @@
+import type { Field } from '../../core/fields';
+import type { C15TOptions } from '../../../types';
+/**
+ * Generates the database table configuration for the consent policy entity.
+ *
+ * This function creates a schema definition that includes all standard consent policy 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 policy table customizations
+ * @param policyFields - Additional fields from plugins to include in the policy table
+ * @returns A complete table schema definition with fields, model name, and metadata
+ *
+ * @example
+ * ```typescript
+ * const policyTableSchema = getConsentPolicyTable(c15tOptions);
+ * // Use the schema for migrations or data access
+ * const migrationPlans = generateMigrations(policyTableSchema);
+ * ```
+ */
+export declare function getConsentPolicyTable(options: C15TOptions, policyFields?: Record<string, Field>): {
+    /**
+     * The name of the policy table in the database, configurable through options
+     */
+    entityName: string;
+    /**
+     * The ID prefix for the consent policy table
+     * Used to generate unique prefixed IDs for consent policies
+     */
+    entityPrefix: string;
+    /**
+     * The schema for the consent policy table
+     */
+    schema: import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        version: import("zod").ZodString;
+        name: import("zod").ZodString;
+        effectiveDate: import("zod").ZodDate;
+        expirationDate: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodDate>>;
+        content: import("zod").ZodString;
+        contentHash: 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;
+        createdAt: Date;
+        isActive: boolean;
+        updatedAt: Date;
+        version: string;
+        name: string;
+        effectiveDate: Date;
+        content: string;
+        contentHash: string;
+        expirationDate?: Date | null | undefined;
+    }, {
+        id: string;
+        version: string;
+        name: string;
+        effectiveDate: Date;
+        content: string;
+        contentHash: string;
+        createdAt?: Date | undefined;
+        isActive?: boolean | undefined;
+        updatedAt?: Date | undefined;
+        expirationDate?: Date | null | undefined;
+    }>;
+    /**
+     * Field definitions for the consent policy table
+     */
+    fields: {
+        /**
+         * Version identifier for the policy (e.g., "1.0.0")
+         */
+        version: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * Human-readable name of the policy
+         */
+        name: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * Date when the policy becomes effective
+         */
+        effectiveDate: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * Optional date when the policy expires
+         */
+        expirationDate: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * Full content of the policy document
+         */
+        content: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * Hash of the content for integrity validation
+         */
+        contentHash: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * Whether this policy is currently active
+         * Default: true
+         */
+        isActive: {
+            type: string;
+            defaultValue: boolean;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * When the policy record was created
+         * Automatically set to current time by default
+         */
+        createdAt: {
+            type: string;
+            defaultValue: () => Date;
+            required: boolean;
+            fieldName: string;
+        };
+    };
+    /**
+     * Execution order during migrations (lower numbers run first)
+     * Policy table needs to be created before tables that reference it (like consent)
+     */
+    order: number;
+};
+//# sourceMappingURL=table.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../../../src/db/schema/consent-policy/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,qBAAqB,CACpC,OAAO,EAAE,WAAW,EACpB,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;IAKnC;;OAEG;;IAGH;;;OAGG;;IAGH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGH;;OAEG;;QAEF;;WAEG;;;;;;QAOH;;WAEG;;;;;;QAOH;;WAEG;;;;;;QAQH;;WAEG;;;;;;QAQH;;WAEG;;;;;;QAOH;;WAEG;;;;;;QAOH;;;WAGG;;;;;;;QAQH;;;WAGG;;;;;;;;IAeJ;;;OAGG;;EAGJ"}

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

@@ -0,0 +1,28 @@
+import type { BaseEntityConfig } from '../types';
+/**
+ * Consent policy entity configuration
+ * @default entityName: "consentPolicy", entityPrefix: "pol"
+ */
+export interface ConsentPolicyEntityConfig extends BaseEntityConfig {
+    fields?: Record<string, string> & {
+        id?: string;
+        version?: string;
+        name?: string;
+        /**
+         * ISO format date string (e.g., "2024-04-15T00:00:00Z")
+         */
+        effectiveDate?: string;
+        /**
+         * ISO format date string (e.g., "2024-04-15T00:00:00Z")
+         */
+        expirationDate?: string;
+        content?: string;
+        contentHash?: string;
+        isActive?: string;
+        /**
+         * ISO format date string (e.g., "2024-04-15T00:00:00Z")
+         */
+        createdAt?: string;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/db/schema/consent-policy/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD;;;GAGG;AACH,MAAM,WAAW,yBAA0B,SAAQ,gBAAgB;IAClE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG;QACjC,EAAE,CAAC,EAAE,MAAM,CAAC;QACZ,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd;;WAEG;QACH,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB;;WAEG;QACH,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB;;WAEG;QACH,SAAS,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC;CACF"}

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

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

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

@@ -0,0 +1,136 @@
+import type { GenericEndpointContext, RegistryContext } from '../../../types';
+import type { ConsentPurpose } from './schema';
+/**
+ * Creates and returns a set of consent consentPurpose-related adapter methods to interact with the database.
+ * These methods provide a consistent interface for creating, finding, and updating
+ * consent consentPurpose 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 consentPurpose operations
+ *
+ * @example
+ * ```typescript
+ * const purposeAdapter = createConsentPurposeAdapter(
+ *   databaseAdapter,
+ *   createWithHooks,
+ *   updateWithHooks,
+ *   c15tOptions
+ * );
+ *
+ * // Create a new consent consentPurpose
+ * const consentPurpose = await purposeAdapter.createConsentPurpose({
+ *   code: 'pur_e8zyhgozr3im7xj59it',
+ *   name: 'Marketing Communications',
+ *   description: 'Allow us to send you marketing materials',
+ *   isEssential: false
+ * });
+ * ```
+ */
+export declare function consentPurposeRegistry({ adapter, ...ctx }: RegistryContext): {
+    /**
+     * Creates a new consent consentPurpose record in the database.
+     * Automatically sets creation and update timestamps and applies any
+     * configured hooks during the creation process.
+     *
+     * @param consentPurpose - ConsentPurpose data to create (without id and timestamps)
+     * @param context - Optional endpoint context for hooks
+     * @returns The created consentPurpose with all fields populated
+     * @throws May throw an error if hooks prevent creation or if database operations fail
+     */
+    createConsentPurpose: (consentPurpose: Omit<ConsentPurpose, "id" | "createdAt" | "updatedAt"> & Partial<ConsentPurpose>, context?: GenericEndpointContext) => Promise<{
+        id: string;
+        code: string;
+        createdAt: Date;
+        isActive: boolean;
+        updatedAt: Date;
+        name: string;
+        description: string;
+        isEssential: boolean;
+        dataCategory?: string | undefined;
+        legalBasis?: string | undefined;
+    }>;
+    /**
+     * Finds all consent purposes, optionally including inactive ones.
+     * Returns purposes with processed output fields according to the schema configuration.
+     *
+     * @param includeInactive - Whether to include inactive purposes (default: false)
+     * @returns Array of consent purposes matching the criteria
+     */
+    findConsentPurposes: (includeInactive?: boolean) => Promise<{
+        id: string;
+        code: string;
+        createdAt: Date;
+        isActive: boolean;
+        updatedAt: Date;
+        name: string;
+        description: string;
+        isEssential: boolean;
+        dataCategory?: string | undefined;
+        legalBasis?: string | undefined;
+    }[]>;
+    /**
+     * Finds a consent consentPurpose by its unique ID.
+     * Returns the consentPurpose with processed output fields according to the schema configuration.
+     *
+     * @param purposeId - The unique identifier of the consentPurpose
+     * @returns The consentPurpose object if found, null otherwise
+     */
+    findConsentPurposeById: (purposeId: string) => Promise<{
+        id: string;
+        code: string;
+        createdAt: Date;
+        isActive: boolean;
+        updatedAt: Date;
+        name: string;
+        description: string;
+        isEssential: boolean;
+        dataCategory?: string | undefined;
+        legalBasis?: string | undefined;
+    } | null>;
+    /**
+     * Finds a consent consentPurpose by its unique code.
+     * Returns the consentPurpose with processed output fields according to the schema configuration.
+     *
+     * @param code - The unique code of the consentPurpose
+     * @returns The consentPurpose object if found, null otherwise
+     */
+    findConsentPurposeByCode: (code: string) => Promise<{
+        id: string;
+        code: string;
+        createdAt: Date;
+        isActive: boolean;
+        updatedAt: Date;
+        name: string;
+        description: string;
+        isEssential: boolean;
+        dataCategory?: string | undefined;
+        legalBasis?: string | undefined;
+    } | null>;
+    /**
+ *
+    /**
+ *
+     * Updates an existing consent consentPurpose record by ID.
+     * Applies any configured hooks during the update process and
+     * processes the output according to schema configuration.
+     *
+     * @param purposeId - The unique identifier of the consentPurpose to update
+     * @param data - The fields to update on the consentPurpose record
+     * @param context - Optional endpoint context for hooks
+     * @returns The updated consentPurpose if successful, null if not found or hooks prevented update
+     */
+    updateConsentPurpose: (purposeId: string, data: Partial<ConsentPurpose>, context?: GenericEndpointContext) => Promise<{
+        id: string;
+        code: string;
+        createdAt: Date;
+        isActive: boolean;
+        updatedAt: Date;
+        name: string;
+        description: string;
+        isEssential: boolean;
+        dataCategory?: string | undefined;
+        legalBasis?: string | undefined;
+    } | null>;
+};
+//# sourceMappingURL=registry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../src/db/schema/consent-purpose/registry.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAEvE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,OAAO,EAAE,GAAG,GAAG,EAAE,EAAE,eAAe;IAGzE;;;;;;;;;OASG;2CAEc,IAAI,CAAC,cAAc,EAAE,IAAI,GAAG,WAAW,GAAG,WAAW,CAAC,GACrE,OAAO,CAAC,cAAc,CAAC,YACd,sBAAsB;;;;;;;;;;;;IA0BjC;;;;;;OAMG;4CAC2C,OAAO;;;;;;;;;;;;IAwBrD;;;;;;OAMG;wCACuC,MAAM;;;;;;;;;;;;IAehD;;;;;;OAMG;qCACoC,MAAM;;;;;;;;;;;;IAe7C;;;;;;;;;;;;OAYG;sCAES,MAAM,QACX,OAAO,CAAC,cAAc,CAAC,YACnB,sBAAsB;;;;;;;;;;;;EAqBlC"}

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

@@ -0,0 +1,79 @@
+import { z } from 'zod';
+/**
+ * Zod schema for validating consent consentPurpose entities.
+ *
+ * This defines the structure and validation rules for consent consentPurpose records:
+ * - Required fields: code, name, description
+ * - Default value of false for isEssential
+ * - Default value of true for isActive
+ * - Optional fields for dataCategory and legalBasis
+ * - Default current date/time for creation and update timestamps
+ *
+ * @example
+ * ```typescript
+ * const purposeData = {
+ *   id: 'pur_e8zyhgozr3im7xj59it',
+ *   code: 'marketing',
+ *   name: 'Marketing Communications',
+ *   description: 'Allow us to send you marketing materials',
+ *   isEssential: false
+ * };
+ *
+ * // Validate and parse the consentPurpose data
+ * const validPurpose = purposeSchema.parse(purposeData);
+ *
+ * // Example with missing fields (defaults will be applied)
+ * const minimalPurposeData = {
+ *   id: 'pur_e8zyhgozr3im7xj59it',
+ *   code: 'marketing',
+ *   name: 'Marketing Communications',
+ *   description: 'Allow us to send you marketing materials',
+ * };
+ *
+ * // isEssential will default to false, isActive to true, etc.
+ * const purposeWithDefaults = purposeSchema.parse(minimalPurposeData);
+ * ```
+ */
+export declare const purposeSchema: z.ZodObject<{
+    id: z.ZodString;
+    code: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    isEssential: z.ZodDefault<z.ZodBoolean>;
+    dataCategory: z.ZodOptional<z.ZodString>;
+    legalBasis: z.ZodOptional<z.ZodString>;
+    isActive: z.ZodDefault<z.ZodBoolean>;
+    createdAt: z.ZodDefault<z.ZodDate>;
+    updatedAt: z.ZodDefault<z.ZodDate>;
+}, "strip", z.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;
+}>;
+/**
+ * Type definition for ConsentPurpose
+ *
+ * This type represents the structure of a consent consentPurpose record
+ * as defined by the purposeSchema. It includes all fields
+ * that are part of the consent consentPurpose entity.
+ */
+export type ConsentPurpose = z.infer<typeof purposeSchema>;
+//# sourceMappingURL=schema.d.ts.map

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

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