@c15t/backend 0.0.1-rc.10

package/dist/db/schema/geo-location/table.d.ts

@@ -0,0 +1,132 @@
+import type { Field } from '../../core/fields';
+import type { C15TOptions } from '../../../types';
+/**
+ * Generates the database table configuration for the geo-location entity.
+ *
+ * This function creates a schema definition that includes all standard geo-location 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 geo-location table customizations
+ * @param geoLocationFields - Additional fields from plugins to include in the geo-location table
+ * @returns A complete table schema definition with fields, model name, and metadata
+ *
+ * @example
+ * ```typescript
+ * const locationTableSchema = getGeoLocationTable(c15tOptions);
+ * // Use the schema for migrations or data access
+ * const migrationPlans = generateMigrations(locationTableSchema);
+ * ```
+ */
+export declare function getGeoLocationTable(options: C15TOptions, geoLocationFields?: Record<string, Field>): {
+    /**
+     * The name of the geo-location table in the database, configurable through options
+     */
+    entityName: string;
+    /**
+     * The ID prefix for the geo-location table
+     * Used to generate unique prefixed IDs for geo-locations
+     */
+    entityPrefix: string;
+    /**
+     * The schema for the geo-location table
+     */
+    schema: import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        countryCode: import("zod").ZodString;
+        countryName: import("zod").ZodString;
+        regionCode: import("zod").ZodOptional<import("zod").ZodString>;
+        regionName: import("zod").ZodOptional<import("zod").ZodString>;
+        regulatoryZones: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<["GDPR", "CCPA", "CPRA", "LGPD", "PIPEDA"]>, "many">>;
+        createdAt: import("zod").ZodDefault<import("zod").ZodDate>;
+    }, "strip", import("zod").ZodTypeAny, {
+        id: string;
+        createdAt: Date;
+        countryCode: string;
+        countryName: string;
+        regionCode?: string | undefined;
+        regionName?: string | undefined;
+        regulatoryZones?: ("GDPR" | "CCPA" | "CPRA" | "LGPD" | "PIPEDA")[] | undefined;
+    }, {
+        id: string;
+        countryCode: string;
+        countryName: string;
+        createdAt?: Date | undefined;
+        regionCode?: string | undefined;
+        regionName?: string | undefined;
+        regulatoryZones?: ("GDPR" | "CCPA" | "CPRA" | "LGPD" | "PIPEDA")[] | undefined;
+    }>;
+    /**
+     * Field definitions for the geo-location table
+     */
+    fields: {
+        /**
+         * Country code (e.g., 'US', 'DE', 'FR')
+         */
+        countryCode: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * Full country name (e.g., 'United States', 'Germany', 'France')
+         */
+        countryName: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * Region or state code (e.g., 'CA', 'NY', 'BY')
+         */
+        regionCode: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * Full region or state name (e.g., 'California', 'New York', 'Bavaria')
+         */
+        regionName: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * Array of regulatory zones that apply to this location (e.g., 'GDPR', 'CCPA')
+         * Stored as a JSON string in the database
+         */
+        regulatoryZones: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+            transformer: {
+                input: (value: string[]) => string;
+                output: (value: string) => any;
+            };
+        };
+        /**
+         * When the geo-location record was created
+         * Automatically set to current time by default
+         */
+        createdAt: {
+            type: string;
+            defaultValue: () => Date;
+            required: boolean;
+            fieldName: string;
+        };
+    };
+    /**
+     * Add indexes for better query performance
+     */
+    indexes: {
+        name: string;
+        fields: string[];
+    }[];
+    /**
+     * Execution order during migrations (lower numbers run first)
+     * Geo-location is a base entity that doesn't depend on other tables
+     */
+    order: number;
+};
+//# sourceMappingURL=table.d.ts.map

package/dist/db/schema/geo-location/table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../../../src/db/schema/geo-location/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,mBAAmB,CAClC,OAAO,EAAE,WAAW,EACpB,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;IAIxC;;OAEG;;IAGH;;;OAGG;;IAGH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;IAGH;;OAEG;;QAEF;;WAEG;;;;;;QAOH;;WAEG;;;;;;QAOH;;WAEG;;;;;;QAOH;;WAEG;;;;;;QAOH;;;WAGG;;;;;;+BAOc,MAAM,EAAE;gCACP,MAAM;;;QAUxB;;;WAGG;;;;;;;;IAeJ;;OAEG;;;;;IAgBH;;;OAGG;;EAGJ"}

package/dist/db/schema/geo-location/types.d.ts

@@ -0,0 +1,17 @@
+import type { BaseEntityConfig } from '../types';
+/**
+ * Geo location entity configuration
+ * @default entityName: "geoLocation", entityPrefix: "geo"
+ */
+export interface GeoLocationEntityConfig extends BaseEntityConfig {
+    fields?: Record<string, string> & {
+        id?: string;
+        countryCode?: string;
+        countryName?: string;
+        regionCode?: string;
+        regionName?: string;
+        regulatoryZones?: string;
+        createdAt?: string;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/db/schema/geo-location/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/db/schema/geo-location/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD;;;GAGG;AACH,MAAM,WAAW,uBAAwB,SAAQ,gBAAgB;IAChE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG;QACjC,EAAE,CAAC,EAAE,MAAM,CAAC;QACZ,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,UAAU,CAAC,EAAE,MAAM,CAAC;QAEpB,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,SAAS,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC;CACF"}

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

@@ -0,0 +1,85 @@
+/**
+ * Schema Module for c15t Consent Management System
+ *
+ * This module serves as the central hub for database schema definitions, validation,
+ * and transformation utilities used throughout the c15t system. It defines the structure
+ * of all database tables and provides tools to work with schema-compliant data.
+ *
+ * @remarks
+ * The Schema Module is organized into three main components:
+ *
+ * 1. Table Definitions - Individual table schemas (subject, consent, consentPurpose, etc.)
+ * 2. Schema Utilities - Functions for retrieving and working with the complete schema
+ * 3. Data Parsing - Validation and transformation of input/output data
+ *
+ * These components work together to provide a type-safe, consistent interface for
+ * interacting with the database, regardless of which database adapter is used.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   getConsentTables,
+ *   parseInputData,
+ *   type C15TDBSchema
+ * } from '@c15t/core/db/schema';
+ *
+ * // Get the complete schema
+ * const tables = getConsentTables(options);
+ *
+ * // Validate input data against the subject table schema
+ * const validSubjectData = parseInputData(
+ *   inputData,
+ *   { fields: tables.subject.fields }
+ * );
+ * ```
+ */
+/**
+ * Table definitions for core c15t entities
+ *
+ * These exports provide the schema definitions for each table in the c15t database.
+ * Each table definition includes field specifications, relationships, and metadata.
+ */
+export * from './audit-log';
+export * from './consent-geo-location';
+export * from './consent-policy';
+export * from './consent-purpose-junction';
+export * from './consent-purpose';
+export * from './consent-record';
+export * from './consent-withdrawal';
+export * from './consent';
+export * from './domain';
+export * from './geo-location';
+export * from './subject';
+/**
+ * Type definitions for database schema configuration
+ *
+ * These exports provide interfaces for configuring database entities
+ * and are used throughout the application for type-safe schema definition.
+ *
+ * @see {@link BaseEntityConfig} - Base configuration for all entities
+ * @see {@link TablesConfig} - Configuration for all database tables
+ */
+export * from './types';
+/**
+ * Schema utilities for working with the complete database schema
+ *
+ * These exports provide functions for retrieving the complete schema and
+ * working with table definitions at a higher level.
+ *
+ * @see {@link getConsentTables} - Main function to get the complete schema
+ * @see {@link C15TDBSchema} - Type representing the complete database schema
+ */
+export { getConsentTables, type C15TDBSchema } from './definition';
+/**
+ * Data parsing and validation utilities
+ *
+ * These exports provide functions for validating and transforming data
+ * according to the schema definitions. They ensure type safety and data integrity
+ * when working with database records.
+ *
+ * @see {@link parseInputData} - Validates input data against a table schema
+ * @see {@link parseEntityOutputData} - Validates output data against a table schema
+ * @see {@link getAllFields} - Retrieves all fields from a schema
+ */
+export { parseInputData, parseEntityOutputData, getAllFields, } from './parser';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/db/schema/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAGH;;;;;GAKG;AACH,cAAc,aAAa,CAAC;AAC5B,cAAc,wBAAwB,CAAC;AACvC,cAAc,kBAAkB,CAAC;AACjC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAG1B;;;;;;;;GAQG;AACH,cAAc,SAAS,CAAC;AAGxB;;;;;;;;GAQG;AACH,OAAO,EAAE,gBAAgB,EAAE,KAAK,YAAY,EAAE,MAAM,cAAc,CAAC;AAGnE;;;;;;;;;;GAUG;AACH,OAAO,EACN,cAAc,EACd,qBAAqB,EACrB,YAAY,GACZ,MAAM,UAAU,CAAC"}

package/dist/db/schema/parser.d.ts

@@ -0,0 +1,183 @@
+import type { C15TOptions } from '../../types';
+import type { Field } from '../core/fields';
+/**
+ * Parses and transforms output data according to schema field definitions.
+ *
+ * This function filters and processes entity data being returned from the database,
+ * ensuring that only fields marked as returnable are included in the output.
+ *
+ * @typeParam EntityType - The type of entity being processed
+ *
+ * @param data - The raw data object retrieved from the database
+ * @param schema - The schema containing field definitions
+ * @param schema.fields - Record of field definitions for the entity
+ *
+ * @returns The processed data object with appropriate fields included or excluded
+ *
+ * @example
+ * ```typescript
+ * // Get subject data from database
+ * const subjectData = { id: 'sub_x1pftyoufsm7xgo1kv', };
+ *
+ * // Define schema with password field marked as not returnable
+ * const subjectSchema = {
+ *   fields: {
+ *     id: { name: 'id', type: 'string', returned: true },
+ *   }
+ * };
+ *
+ * // Process the data - password will be excluded
+ * const processedData = parseEntityOutputData(subjectData, subjectSchema);
+ * // Result: { id: 'sub_x1pftyoufsm7xgo1kv',}
+ * ```
+ *
+ * @remarks
+ * - Fields marked with `returned: false` will be excluded from the output
+ * - Fields not found in the schema will be passed through unchanged
+ * - The function preserves the original type of the input data
+ */
+export declare function parseEntityOutputData<EntityType extends Record<string, unknown>>(data: EntityType, schema: {
+    fields: Record<string, Field>;
+}): EntityType;
+/**
+ * Type representing a field conflict resolution strategy
+ */
+export type FieldConflictResolution = {
+    /**
+     * How to handle conflicting field definitions
+     * - 'error': Throw an error when conflicts are detected
+     * - 'warn': Log a warning and use the last definition
+     * - 'silent': Silently use the last definition
+     */
+    strategy: 'error' | 'warn' | 'silent';
+    /**
+     * Optional callback for logging warnings
+     * Only used when strategy is 'warn'
+     */
+    onWarning?: (message: string) => void;
+};
+/**
+ * Retrieves all fields for a specific table, combining base configuration and plugin fields
+ *
+ * @param options - The C15T configuration options
+ * @param table - The table name to get fields for
+ * @param conflictResolution - How to handle conflicting field definitions
+ * @returns Combined fields from configuration and plugins
+ *
+ * @throws {C15TError} When field conflicts are detected and strategy is 'error'
+ *
+ * @example
+ * ```typescript
+ * // Get fields with conflict resolution
+ * const fields = getAllFields(options, 'subject', {
+ *   strategy: 'warn',
+ *   onWarning: (msg) => console.warn(msg)
+ * });
+ * ```
+ */
+export declare function getAllFields(options: C15TOptions, table: string, conflictResolution?: FieldConflictResolution): Record<string, Field>;
+/**
+ * Configuration for handling extra fields in input data
+ */
+export type ExtraFieldsConfig = {
+    /**
+     * How to handle fields not defined in the schema
+     * - 'error': Throw an error when extra fields are detected
+     * - 'warn': Log a warning and include the fields
+     * - 'silent': Silently include the fields
+     * - 'drop': Silently drop the fields
+     */
+    strategy: 'error' | 'warn' | 'silent' | 'drop';
+    /**
+     * Optional callback for logging warnings
+     * Only used when strategy is 'warn'
+     */
+    onWarning?: (message: string) => void;
+    /**
+     * Optional list of field names that are always allowed
+     * regardless of schema definition
+     */
+    allowedExtraFields?: string[];
+};
+/**
+ * Parses and validates input data according to schema field definitions.
+ *
+ * This function processes data being sent to the database, ensuring it meets
+ * schema requirements by:
+ * - Validating required fields
+ * - Applying transformations
+ * - Setting default values
+ * - Handling field-specific validation
+ *
+ * @typeParam EntityType - The type of entity being processed
+ *
+ * @param data - The input data to validate and transform
+ * @param schema - The schema to validate against
+ * @param schema.fields - Record of field definitions
+ * @param schema.action - The current operation ('create' or 'update')
+ * @param extraFieldsConfig - How to handle fields not defined in the schema
+ *
+ * @returns The validated and transformed data
+ *
+ * @throws {C15TError} When a required field is missing during creation
+ * @throws {C15TError} When extra fields are detected and strategy is 'error'
+ *
+ * @example
+ * ```typescript
+ * // Input data from client
+ * const inputData = {
+ *   email: 'subject@example.com',
+ *   role: 'subject',
+ *   extraField: 'value' // Field not in schema
+ * };
+ *
+ * // Schema with field definitions
+ * const subjectSchema = {
+ *   fields: {
+ *     id: {
+ *       name: 'id',
+ *       type: 'string',
+ *       defaultValue: () => crypto.randomUUID()
+ *     },
+ *     email: {
+ *       name: 'email',
+ *       type: 'string',
+ *       required: true,
+ *       transform: {
+ *         input: (value) => value.toLowerCase()
+ *       }
+ *     },
+ *     role: {
+ *       name: 'role',
+ *       type: 'string',
+ *       defaultValue: 'subject'
+ *     },
+ *     createdAt: {
+ *       name: 'created_at',
+ *       type: 'date',
+ *       defaultValue: () => new Date(),
+ *       input: false
+ *     }
+ *   },
+ *   action: 'create'
+ * };
+ *
+ * // Process the data with extra fields config
+ * const validatedData = parseInputData(inputData, subjectSchema, {
+ *   strategy: 'warn',
+ *   onWarning: (msg) => console.warn(msg),
+ *   allowedExtraFields: ['metadata']
+ * });
+ * ```
+ *
+ * @remarks
+ * - During 'create' operations, required fields must be present or an error is thrown
+ * - Default values are only applied during 'create' operations
+ * - Fields marked with `input: false` are excluded unless they have a default value
+ * - The function handles both modern transform functions and legacy validators
+ */
+export declare function parseInputData<EntityType extends Record<string, unknown>>(data: EntityType, schema: {
+    fields: Record<string, Field>;
+    action?: 'create' | 'update';
+}, extraFieldsConfig?: ExtraFieldsConfig): Partial<EntityType>;
+//# sourceMappingURL=parser.d.ts.map

package/dist/db/schema/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../../src/db/schema/parser.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAoB,MAAM,SAAS,CAAC;AAC7D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,qBAAqB,CACpC,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAE1C,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE;IACP,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;CAC9B,GAkBoB,UAAU,CAC/B;AAED;;GAEG;AACH,MAAM,MAAM,uBAAuB,GAAG;IACrC;;;;;OAKG;IACH,QAAQ,EAAE,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAC;IAEtC;;;OAGG;IACH,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACtC,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAC3B,OAAO,EAAE,WAAW,EACpB,KAAK,EAAE,MAAM,EACb,kBAAkB,GAAE,uBAA+C,yBA6DnE;AAED;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC/B;;;;;;OAMG;IACH,QAAQ,EAAE,OAAO,GAAG,MAAM,GAAG,QAAQ,GAAG,MAAM,CAAC;IAE/C;;;OAGG;IACH,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAEtC;;;OAGG;IACH,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC9B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4EG;AACH,wBAAgB,cAAc,CAAC,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACxE,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE;IACP,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAC9B,MAAM,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;CAC7B,EACD,iBAAiB,GAAE,iBAAyC,GAuIvC,OAAO,CAAC,UAAU,CAAC,CACxC"}