@c15t/backend 1.8.0 → 2.0.0-rc.1

package/dist/schema/definition.d.ts

@@ -1,586 +0,0 @@
-import type { C15TOptions } from '../types';
-import type { InferTableShape } from './schemas';
-/**
- * Retrieves all consent-related database table definitions
- *
- * This function combines the core tables with any additional tables
- * defined by plugins. It handles merging plugin-defined fields with
- * the standard tables and ensures all table definitions are properly
- * structured for use by database adapters.
- *
- * @param options - The c15t configuration options
- * @returns A complete schema mapping containing all table definitions
- *
- * @remarks
- * Each table definition includes both field definitions and the physical
- * entity name used in the database. Plugins can extend core tables by
- * defining additional fields, which will be merged with the standard fields.
- *
- * @example
- * ```typescript
- * // Get all tables with default configuration
- * const tables = getConsentTables(options);
- *
- * // Access fields for the consent table
- * const consentFields = tables.consent.fields;
- * ```
- */
-export declare const getConsentTables: (options: C15TOptions) => {
-    subject: {
-        entityName: string;
-        entityPrefix: string;
-        schema: import("zod").ZodObject<{
-            id: import("zod").ZodString;
-            isIdentified: import("zod").ZodPrefault<import("zod").ZodBoolean>;
-            externalId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
-            identityProvider: import("zod").ZodOptional<import("zod").ZodString>;
-            lastIpAddress: import("zod").ZodOptional<import("zod").ZodString>;
-            createdAt: import("zod").ZodPrefault<import("zod").ZodDate>;
-            updatedAt: import("zod").ZodPrefault<import("zod").ZodDate>;
-        }, import("zod/v4/core").$strip>;
-        fields: {
-            isIdentified: {
-                type: string;
-                defaultValue: () => boolean;
-                required: boolean;
-                fieldName: string;
-            };
-            externalId: {
-                type: string;
-                required: boolean;
-                fieldName: string;
-            };
-            identityProvider: {
-                type: string;
-                required: boolean;
-                fieldName: string;
-            };
-            lastIpAddress: {
-                type: string;
-                required: boolean;
-                fieldName: string;
-            };
-            createdAt: {
-                type: string;
-                defaultValue: () => Date;
-                required: boolean;
-                fieldName: string;
-            };
-            updatedAt: {
-                type: string;
-                defaultValue: () => Date;
-                required: boolean;
-                fieldName: string;
-            };
-            subjectTimezone: {
-                type: string;
-                required: boolean;
-                defaultValue: "UTC";
-                fieldName: string;
-            };
-        };
-        order: number;
-    };
-    consentPurpose: {
-        entityName: string;
-        entityPrefix: string;
-        schema: import("zod").ZodObject<{
-            id: import("zod").ZodString;
-            code: import("zod").ZodString;
-            name: import("zod").ZodString;
-            description: import("zod").ZodString;
-            isEssential: import("zod").ZodPrefault<import("zod").ZodBoolean>;
-            dataCategory: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
-            legalBasis: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
-            isActive: import("zod").ZodPrefault<import("zod").ZodBoolean>;
-            createdAt: import("zod").ZodPrefault<import("zod").ZodDate>;
-            updatedAt: import("zod").ZodPrefault<import("zod").ZodDate>;
-        }, import("zod/v4/core").$strip>;
-        fields: {
-            code: {
-                type: string;
-                required: boolean;
-                fieldName: string;
-            };
-            name: {
-                type: string;
-                required: boolean;
-                fieldName: string;
-            };
-            description: {
-                type: string;
-                required: boolean;
-                fieldName: string;
-            };
-            isEssential: {
-                type: string;
-                defaultValue: () => boolean;
-                required: boolean;
-                fieldName: string;
-            };
-            dataCategory: {
-                type: string;
-                required: boolean;
-                fieldName: string;
-            };
-            legalBasis: {
-                type: string;
-                required: boolean;
-                fieldName: string;
-            };
-            isActive: {
-                type: string;
-                defaultValue: boolean;
-                required: boolean;
-                fieldName: string;
-            };
-            createdAt: {
-                type: string;
-                defaultValue: () => Date;
-                required: boolean;
-                fieldName: string;
-            };
-            updatedAt: {
-                type: string;
-                defaultValue: () => Date;
-                required: boolean;
-                fieldName: string;
-            };
-        };
-        order: number;
-    };
-    consentPolicy: {
-        entityName: string;
-        entityPrefix: string;
-        schema: import("zod").ZodObject<{
-            id: import("zod").ZodString;
-            version: import("zod").ZodString;
-            type: import("zod").ZodEnum<{
-                cookie_banner: "cookie_banner";
-                privacy_policy: "privacy_policy";
-                dpa: "dpa";
-                terms_and_conditions: "terms_and_conditions";
-                marketing_communications: "marketing_communications";
-                age_verification: "age_verification";
-                other: "other";
-            }>;
-            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").ZodPrefault<import("zod").ZodBoolean>;
-            createdAt: import("zod").ZodPrefault<import("zod").ZodDate>;
-            updatedAt: import("zod").ZodPrefault<import("zod").ZodDate>;
-        }, import("zod/v4/core").$strip>;
-        fields: {
-            version: {
-                type: string;
-                required: boolean;
-                fieldName: string;
-            };
-            type: {
-                type: string;
-                required: boolean;
-                fieldName: string;
-            };
-            name: {
-                type: string;
-                required: boolean;
-                fieldName: string;
-            };
-            effectiveDate: {
-                type: string;
-                required: boolean;
-                fieldName: string | Date;
-            };
-            expirationDate: {
-                type: string;
-                required: boolean;
-                fieldName: string | Date;
-            };
-            content: {
-                type: string;
-                required: boolean;
-                fieldName: string;
-            };
-            contentHash: {
-                type: string;
-                required: boolean;
-                fieldName: string;
-            };
-            isActive: {
-                type: string;
-                defaultValue: boolean;
-                required: boolean;
-                fieldName: string;
-            };
-            createdAt: {
-                type: string;
-                defaultValue: () => Date;
-                required: boolean;
-                fieldName: string;
-            };
-        };
-        order: number;
-    };
-    domain: {
-        entityName: string;
-        entityPrefix: string;
-        schema: import("zod").ZodObject<{
-            id: import("zod").ZodString;
-            name: import("zod").ZodString;
-            description: import("zod").ZodOptional<import("zod").ZodString>;
-            allowedOrigins: import("zod").ZodPrefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>>;
-            isVerified: import("zod").ZodPrefault<import("zod").ZodBoolean>;
-            isActive: import("zod").ZodPrefault<import("zod").ZodBoolean>;
-            createdAt: import("zod").ZodPrefault<import("zod").ZodDate>;
-            updatedAt: import("zod").ZodPrefault<import("zod").ZodDate>;
-        }, import("zod/v4/core").$strip>;
-        fields: {
-            name: {
-                type: string;
-                required: boolean;
-                unique: boolean;
-                fieldName: string;
-            };
-            description: {
-                type: string;
-                required: boolean;
-                fieldName: string;
-            };
-            allowedOrigins: {
-                type: string;
-                defaultValue: () => never[];
-                required: boolean;
-                fieldName: string;
-            };
-            isVerified: {
-                type: string;
-                defaultValue: boolean;
-                required: boolean;
-                fieldName: string;
-            };
-            isActive: {
-                type: string;
-                defaultValue: boolean;
-                required: boolean;
-                fieldName: string;
-            };
-            createdAt: {
-                type: string;
-                defaultValue: () => Date;
-                required: boolean;
-                fieldName: string;
-            };
-            updatedAt: {
-                type: string;
-                required: boolean;
-                fieldName: string;
-            };
-        };
-        order: number;
-    };
-    consent: {
-        entityName: string;
-        entityPrefix: string;
-        schema: import("zod").ZodObject<{
-            id: import("zod").ZodString;
-            subjectId: import("zod").ZodString;
-            domainId: import("zod").ZodString;
-            purposeIds: import("zod").ZodArray<import("zod").ZodString>;
-            metadata: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
-            policyId: import("zod").ZodOptional<import("zod").ZodString>;
-            ipAddress: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
-            userAgent: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
-            status: import("zod").ZodPrefault<import("zod").ZodEnum<{
-                active: "active";
-                withdrawn: "withdrawn";
-                expired: "expired";
-            }>>;
-            withdrawalReason: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
-            givenAt: import("zod").ZodPrefault<import("zod").ZodDate>;
-            validUntil: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodDate>>;
-            isActive: import("zod").ZodPrefault<import("zod").ZodBoolean>;
-        }, import("zod/v4/core").$strip>;
-        fields: {
-            subjectId: {
-                type: string;
-                required: boolean;
-                fieldName: string;
-                references: {
-                    model: string;
-                    field: string;
-                };
-            };
-            domainId: {
-                type: string;
-                required: boolean;
-                fieldName: string;
-                references: {
-                    model: string;
-                    field: string;
-                };
-            };
-            purposeIds: {
-                type: string;
-                required: boolean;
-                fieldName: string;
-            };
-            metadata: {
-                type: string;
-                required: boolean;
-                fieldName: string;
-            };
-            policyId: {
-                type: string;
-                required: boolean;
-                fieldName: string;
-                references: {
-                    model: string;
-                    field: string;
-                };
-            };
-            ipAddress: {
-                type: string;
-                required: boolean;
-                fieldName: string;
-            };
-            userAgent: {
-                type: string;
-                required: boolean;
-                fieldName: string;
-            };
-            status: {
-                type: string;
-                defaultValue: () => string;
-                required: boolean;
-                fieldName: string;
-            };
-            withdrawalReason: {
-                type: string;
-                required: boolean;
-                fieldName: string;
-            };
-            givenAt: {
-                type: string;
-                defaultValue: () => Date;
-                required: boolean;
-                fieldName: string;
-            };
-            validUntil: {
-                type: string;
-                required: boolean;
-                fieldName: string;
-                transform: {
-                    input: (val: Date | undefined, data: Record<string, unknown>) => Date | undefined;
-                };
-            };
-            isActive: {
-                type: string;
-                defaultValue: boolean;
-                required: boolean;
-                fieldName: string;
-            };
-        };
-        order: number;
-    };
-    consentRecord: {
-        entityName: string;
-        entityPrefix: string;
-        schema: import("zod").ZodObject<{
-            id: import("zod").ZodString;
-            subjectId: import("zod").ZodString;
-            consentId: import("zod").ZodOptional<import("zod").ZodString>;
-            actionType: import("zod").ZodString;
-            details: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
-            createdAt: import("zod").ZodPrefault<import("zod").ZodDate>;
-            updatedAt: import("zod").ZodPrefault<import("zod").ZodDate>;
-        }, import("zod/v4/core").$strip>;
-        fields: {
-            subjectId: {
-                type: string;
-                required: boolean;
-                fieldName: string;
-                references: {
-                    model: string;
-                    field: string;
-                };
-            };
-            consentId: {
-                type: string;
-                required: boolean;
-                fieldName: string;
-                references: {
-                    model: string;
-                    field: string;
-                };
-            };
-            actionType: {
-                type: string;
-                required: boolean;
-                fieldName: string;
-            };
-            details: {
-                type: string;
-                required: boolean;
-                fieldName: string;
-            };
-            createdAt: {
-                type: string;
-                defaultValue: () => Date;
-                required: boolean;
-                fieldName: string;
-            };
-        };
-        order: number;
-    };
-    auditLog: {
-        entityName: string;
-        entityPrefix: string;
-        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").ZodPrefault<import("zod").ZodDate>;
-        }, import("zod/v4/core").$strip>;
-        fields: {
-            entityType: {
-                type: string;
-                required: boolean;
-                fieldName: string;
-            };
-            entityId: {
-                type: string;
-                required: boolean;
-                fieldName: string;
-            };
-            actionType: {
-                type: string;
-                required: boolean;
-                fieldName: string;
-            };
-            subjectId: {
-                type: string;
-                required: boolean;
-                fieldName: string;
-                references: {
-                    model: string;
-                    field: string;
-                };
-            };
-            ipAddress: {
-                type: string;
-                required: boolean;
-                fieldName: string;
-            };
-            userAgent: {
-                type: string;
-                required: boolean;
-                fieldName: string;
-            };
-            changes: {
-                type: string;
-                required: boolean;
-                fieldName: string;
-            };
-            metadata: {
-                type: string;
-                required: boolean;
-                fieldName: string;
-            };
-            createdAt: {
-                type: string;
-                defaultValue: () => Date;
-                required: boolean;
-                fieldName: string;
-            };
-            eventTimezone: {
-                type: string;
-                required: boolean;
-                defaultValue: "UTC";
-                fieldName: string;
-            };
-        };
-        indexes: {
-            name: string;
-            fields: string[];
-        }[];
-        order: number;
-    };
-};
-/**
- * Type representing the complete database schema for c15t
- *
- * This type captures the full structure of all tables in the database,
- * including core tables and any plugin-defined tables. It's derived from
- * the return type of `getConsentTables()`.
- *
- * @remarks
- * This is a key type for type-safety throughout the codebase, as it
- * ensures that table names and field references are validated at compile time.
- * It's used as a basis for many other type definitions in the database layer.
- *
- * @example
- * ```typescript
- * // Type-safe reference to a specific table
- * function processTable<TableName extends keyof C15TDBSchema>(
- *   tableName: TableName,
- *   data: Record<string, unknown>
- * ) {
- *   const tableFields = getConsentTables(options)[tableName].fields;
- *   // Process with type safety...
- * }
- * ```
- */
-export type C15TDBSchema = ReturnType<typeof getConsentTables>;
-/**
- * Type to get all output fields of a table by its name
- * This type extracts only the fields that are included in output operations,
- * automatically excluding fields marked with { returned: false }.
- * It also resolves relationships between tables.
- */
-export type EntityOutputFields<TableName extends keyof C15TDBSchema> = InferTableShape<TableName>;
-/**
- * Validates output data against table schema using Zod
- *
- * This function validates and transforms output data according to the
- * schema definition for a specific table. It ensures that all values match
- * their expected types and excludes fields marked as not to be returned.
- *
- * @typeParam TableName - The table name from C15TDBSchema
- * @param tableName - The name of the table to validate against
- * @param data - The data to validate
- * @param options - The C15TOptions instance
- * @returns Validated and typed data
- * @throws {Error} If the table is not found or validation fails
- *
- * @remarks
- * This function is particularly useful for validating data received from
- * external sources or database adapters before processing it in application logic.
- *
- * @example
- * ```typescript
- * // Validate data retrieved from an external API
- * try {
- *   const validSubjectOutput = validateEntityOutput(
- *     'subject',
- *     fetchedSubjectData,
- *     options
- *   );
- *
- *   // validSubjectOutput is now typed as EntityOutputFields<'subject'>
- *   displaySubjectProfile(validSubjectOutput);
- * } catch (error) {
- *   console.error('Output validation failed:', error.message);
- * }
- * ```
- */
-export declare function validateEntityOutput<TableName extends keyof C15TDBSchema>(tableName: TableName, data: Record<string, unknown>, options: C15TOptions): EntityOutputFields<TableName>;
-//# sourceMappingURL=definition.d.ts.map

package/dist/schema/definition.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/schema/definition.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAO3C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAGjD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,gBAAgB,GAAI,SAAS,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2CpD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE/D;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,CAAC,SAAS,SAAS,MAAM,YAAY,IAClE,eAAe,CAAC,SAAS,CAAC,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,SAAS,MAAM,YAAY,EACxE,SAAS,EAAE,SAAS,EACpB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,EAAE,WAAW,GAClB,kBAAkB,CAAC,SAAS,CAAC,CA0C/B"}

package/dist/schema/domain/index.d.ts

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

package/dist/schema/domain/index.d.ts.map

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