@c15t/backend 1.8.0 → 2.0.0-rc.1

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

@@ -1,222 +0,0 @@
-import type { GenericEndpointContext, RegistryContext } from '../../pkgs/types';
-import type { Domain } from './schema';
-export interface FindDomainParams {
-    name?: string;
-    includeInactive?: boolean;
-}
-/**
- * Creates and returns a set of domain-related adapter methods to interact with the database.
- * These methods provide a consistent interface for creating, finding, and updating
- * domain records while applying hooks and enforcing data validation rules.
- *
- * The domain registry manages domain entities that represent websites or applications
- * where consent can be collected. Domains have verification status, active status,
- * and can specify allowed origins for cross-domain operations.
- *
- * @param params - Registry context parameters
- * @param params.adapter - The database adapter used for direct database operations
- * @param params.ctx - Additional context properties containing hooks and options
- * @returns An object containing type-safe domain operations
- *
- * @example
- * ```ts
- * const registry = domainRegistry({
- *   adapter: databaseAdapter,
- *   hooks: customHooks,
- *   options: validationOptions
- * });
- *
- * // Create a new domain
- * const domain = await registry.createDomain({
- *   name: 'example.com',
- *   description: 'Example company website',
- *   isVerified: true,
- *   allowedOrigins: ['https://app.example.com']
- * });
- * ```
- *
- * @see {@link RegistryContext} For details on the context parameters
- * @see {@link Domain} For the structure of domain objects
- */
-export declare function domainRegistry({ adapter, ...ctx }: RegistryContext): {
-    /**
-     * Creates a new domain record in the database.
-     *
-     * This method creates a domain entity that represents a website or application
-     * where consent can be collected. It automatically sets creation and update
-     * timestamps and applies any configured hooks during the creation process.
-     *
-     * @param domain - Domain data to create (without id and timestamps)
-     * @param domain.name - Unique domain name (e.g., 'example.com')
-     * @param domain.description - Optional description of the domain's purpose
-     * @param domain.isActive - Whether the domain is currently active
-     * @param domain.isVerified - Whether domain ownership has been verified
-     * @param domain.allowedOrigins - Array of origins allowed to access this domain's data
-     * @param context - Optional endpoint context for hooks execution
-     * @returns Promise resolving to the created domain with all fields populated
-     * @throws {Error} When the creation operation fails or returns null
-     * @throws May also throw errors if hooks prevent creation or if validation fails
-     *
-     * @example
-     * ```ts
-     * // Create a new active and verified domain
-     * const newDomain = await registry.createDomain({
-     *   name: 'example.org',
-     *   description: 'Example organization website',
-     *   isActive: true,
-     *   isVerified: true,
-     *   allowedOrigins: ['https://app.example.org', 'https://admin.example.org']
-     * });
-     * ```
-     *
-     * @see {@link Domain} For the complete structure of domain objects
-     * @see {@link GenericEndpointContext} For details on the context object
-     */
-    createDomain: (domain: Omit<Domain, "id" | "createdAt" | "updatedAt"> & Partial<Domain>, context?: GenericEndpointContext) => Promise<{
-        id: string;
-        name: string;
-        allowedOrigins: string[];
-        isVerified: boolean;
-        isActive: boolean;
-        createdAt: Date;
-        updatedAt: Date;
-        description?: string | undefined;
-    }>;
-    /**
-     * Finds an existing domain or creates a new one if needed.
-     *
-     * This method attempts to find a domain with the specified name. If not found,
-     * it automatically creates a new domain with default settings and the given name.
-     * This is useful for ensuring a domain exists before associating other entities with it.
-     *
-     * @param name - The domain name to find or create
-     * @param context - Optional endpoint context for hooks execution
-     * @returns Promise resolving to the existing or newly created domain
-     * @throws {DoubleTieError} If domain creation fails
-     *
-     * @example
-     * ```ts
-     * // Find or create a domain for 'example.net'
-     * const domain = await registry.findOrCreateDomain('example.net');
-     * console.log(`Using domain: ${domain.name} (${domain.id})`);
-     * console.log(`Domain was ${domain.createdAt === domain.updatedAt ? 'newly created' : 'existing'}`);
-     * ```
-     *
-     * @see {@link findDomainByName} For the underlying lookup method
-     * @see {@link createDomain} For the underlying creation method
-     */
-    findOrCreateDomain: (name: string, context?: GenericEndpointContext) => Promise<{
-        id: string;
-        name: string;
-        allowedOrigins: string[];
-        isVerified: boolean;
-        isActive: boolean;
-        createdAt: Date;
-        updatedAt: Date;
-        description?: string | undefined;
-    }>;
-    /**
-     * Finds all domains matching the specified criteria.
-     *
-     * This method retrieves domains from the database, with optional filtering by name
-     * and active status. Results are sorted alphabetically by name and validated
-     * against the schema before being returned.
-     *
-     * @param params - Optional parameters to filter the results
-     * @param params.name - Optional domain name to filter by
-     * @param params.includeInactive - When true, includes inactive domains in the results
-     * @returns Promise resolving to an array of validated domain objects
-     *
-     * @example
-     * ```ts
-     * // Get all active domains
-     * const activeDomains = await registry.findDomains();
-     *
-     * // Get all domains including inactive ones
-     * const allDomains = await registry.findDomains({ includeInactive: true });
-     *
-     * // Find domains with a specific name
-     * const specificDomains = await registry.findDomains({ name: 'example.com' });
-     * ```
-     *
-     * @see {@link FindDomainParams} For details on filter parameters
-     * @see {@link Domain} For the structure of returned domain objects
-     */
-    findDomains: (params?: FindDomainParams) => Promise<{
-        id: string;
-        name: string;
-        allowedOrigins: string[];
-        isVerified: boolean;
-        isActive: boolean;
-        createdAt: Date;
-        updatedAt: Date;
-        description?: string | undefined;
-    }[]>;
-    /**
-     * Finds a domain by its name.
-     *
-     * This is a convenience method that wraps findDomains with a name filter
-     * and returns the first matching active domain, or null if none is found.
-     *
-     * @param name - The domain name to search for
-     * @returns Promise resolving to the domain object if found, null otherwise
-     *
-     * @example
-     * ```ts
-     * // Find a domain by name
-     * const domain = await registry.findDomain('example.com');
-     * if (domain) {
-     *   console.log(`Found domain: ${domain.name}`);
-     * } else {
-     *   console.log('Domain not found or inactive');
-     * }
-     * ```
-     *
-     * @see {@link findDomains} For the underlying search method
-     * @see {@link Domain} For the structure of the returned domain object
-     */
-    findDomain: (name: string) => Promise<{
-        id: string;
-        name: string;
-        allowedOrigins: string[];
-        isVerified: boolean;
-        isActive: boolean;
-        createdAt: Date;
-        updatedAt: Date;
-        description?: string | undefined;
-    } | null>;
-    /**
-     * Finds a domain by its name, including inactive domains.
-     *
-     * This method directly queries the database for a domain with the exact
-     * name specified, regardless of active status. The resulting domain is
-     * validated against the schema before being returned.
-     *
-     * @param name - The domain name to search for
-     * @returns Promise resolving to the validated domain object if found, null otherwise
-     *
-     * @example
-     * ```ts
-     * // Find a domain by name (even if inactive)
-     * const domain = await registry.findDomainByName('example.com');
-     * if (domain) {
-     *   console.log(`Found domain: ${domain.name} (${domain.isActive ? 'active' : 'inactive'})`);
-     * } else {
-     *   console.log('Domain not found');
-     * }
-     * ```
-     *
-     * @see {@link Domain} For the structure of the returned domain object
-     */
-    findDomainByName: (name: string) => Promise<{
-        id: string;
-        name: string;
-        allowedOrigins: string[];
-        isVerified: boolean;
-        isActive: boolean;
-        createdAt: Date;
-        updatedAt: Date;
-        description?: string | undefined;
-    } | null>;
-};
-//# sourceMappingURL=registry.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/schema/domain/registry.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAG5E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAEvC,MAAM,WAAW,gBAAgB;IAChC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,eAAe,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,cAAc,CAAC,EAAE,OAAO,EAAE,GAAG,GAAG,EAAE,EAAE,eAAe;IAGjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;2BAEM,IAAI,CAAC,MAAM,EAAE,IAAI,GAAG,WAAW,GAAG,WAAW,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,YAC9D,sBAAsB;;;;;;;;;;IA0BjC;;;;;;;;;;;;;;;;;;;;;;OAsBG;+BAEI,MAAM,YACF,sBAAsB;;;;;;;;;;IA8BjC;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;2BACyB,gBAAgB;;;;;;;;;;IA+B5C;;;;;;;;;;;;;;;;;;;;;;OAsBG;uBACsB,MAAM;;;;;;;;;;IAQ/B;;;;;;;;;;;;;;;;;;;;;;OAsBG;6BAC4B,MAAM;;;;;;;;;;EAiBtC"}

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

@@ -1,42 +0,0 @@
-import { z } from 'zod';
-/**
- * Zod schema for validating domain entities.
- *
- * This defines the structure and validation rules for domain records:
- * - Required fields: name
- * - Optional fields: description, allowedOrigins
- * - Default value of true for isActive and isVerified
- * - Default current date/time for creation timestamp
- *
- * @example
- * ```typescript
- * const domainData = {
- *   id: 'dom_x1pftyoufsm7xgo1kv',
- *   name: 'example.com',
- *   description: 'Company website',
- *   allowedOrigins: ['https://app.example.com', 'https://admin.example.com']
- * };
- *
- * // Validate and parse the domain data
- * const validDomain = domainSchema.parse(domainData);
- * ```
- */
-export declare const domainSchema: z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    allowedOrigins: z.ZodPrefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-    isVerified: z.ZodPrefault<z.ZodBoolean>;
-    isActive: z.ZodPrefault<z.ZodBoolean>;
-    createdAt: z.ZodPrefault<z.ZodDate>;
-    updatedAt: z.ZodPrefault<z.ZodDate>;
-}, z.core.$strip>;
-/**
- * Type definition for Domain
- *
- * This type represents the structure of a domain record
- * as defined by the domainSchema. It includes all fields
- * that are part of the domain entity.
- */
-export type Domain = z.infer<typeof domainSchema>;
-//# sourceMappingURL=schema.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/schema/domain/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,YAAY;;;;;;;;;iBASvB,CAAC;AAEH;;;;;;GAMG;AACH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC"}

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

@@ -1,122 +0,0 @@
-import type { Field } from '../../pkgs/data-model';
-import type { C15TOptions } from '../../types';
-/**
- * Generates the database table configuration for the domain entity.
- *
- * This function creates a schema definition that includes all standard domain 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 domain table customizations
- * @param domainFields - Additional fields from plugins to include in the domain table
- * @returns A complete table schema definition with fields, model name, and metadata
- *
- * @example
- * ```typescript
- * const domainTableSchema = getDomainTable(c15tOptions);
- * // Use the schema for migrations or data access
- * const migrationPlans = generateMigrations(domainTableSchema);
- * ```
- */
-export declare function getDomainTable(options: C15TOptions, domainFields?: Record<string, Field>): {
-    /**
-     * The name of the domain table in the database, configurable through options
-     */
-    entityName: string;
-    /**
-     * The ID prefix for the domain table
-     * Used to generate unique prefixed IDs for domains
-     */
-    entityPrefix: string;
-    /**
-     * The schema for the domain table
-     */
-    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>;
-    /**
-     * Field definitions for the domain table
-     */
-    fields: {
-        /**
-         * Domain name (e.g., "example.com")
-         * This is the primary identifier for the domain in addition to its ID
-         */
-        name: {
-            type: string;
-            required: boolean;
-            unique: boolean;
-            fieldName: string;
-        };
-        /**
-         * Optional human-readable description of the domain
-         */
-        description: {
-            type: string;
-            required: boolean;
-            fieldName: string;
-        };
-        /**
-         * List of additional origins that are allowed to access resources for this domain
-         * Stored as a JSON array of strings
-         */
-        allowedOrigins: {
-            type: string;
-            defaultValue: () => never[];
-            required: boolean;
-            fieldName: string;
-        };
-        /**
-         * Whether domain ownership has been verified
-         * Default: true
-         */
-        isVerified: {
-            type: string;
-            defaultValue: boolean;
-            required: boolean;
-            fieldName: string;
-        };
-        /**
-         * Whether this domain is currently active
-         * Default: true
-         */
-        isActive: {
-            type: string;
-            defaultValue: boolean;
-            required: boolean;
-            fieldName: string;
-        };
-        /**
-         * When the domain record was created
-         * Automatically set to current time by default
-         */
-        createdAt: {
-            type: string;
-            defaultValue: () => Date;
-            required: boolean;
-            fieldName: string;
-        };
-        /**
-         * When the domain record was last updated
-         * Optional, set during updates
-         */
-        updatedAt: {
-            type: string;
-            required: boolean;
-            fieldName: string;
-        };
-    };
-    /**
-     * Execution order during migrations (lower numbers run first)
-     * Domain table needs to be created before tables that reference it
-     */
-    order: number;
-};
-//# sourceMappingURL=table.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../../src/schema/domain/table.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAG3C;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAC7B,OAAO,EAAE,WAAW,EACpB,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;IAKnC;;OAEG;;IAGH;;;OAGG;;IAGH;;OAEG;;;;;;;;;;;IAGH;;OAEG;;QAEF;;;WAGG;;;;;;;QAQH;;WAEG;;;;;;QAOH;;;WAGG;;;;;;;QAQH;;;WAGG;;;;;;;QAQH;;;WAGG;;;;;;;QAQH;;;WAGG;;;;;;;QAQH;;;WAGG;;;;;;;IAcJ;;;OAGG;;EAGJ"}

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

@@ -1,27 +0,0 @@
-import type { ActiveEntityConfig } from '../types';
-/**
- * Domain entity configuration
- * @default entityName: "domain", entityPrefix: "dom"
- */
-export interface DomainEntityConfig extends ActiveEntityConfig {
-    fields?: Record<string, string> & {
-        id?: string;
-        domain: string;
-        /**
-         * Indicates if the domain is a pattern (e.g., "true"/"false")
-         * When true, the domain string will be interpreted as a pattern
-         */
-        isPattern?: string;
-        /**
-         * The type of pattern matching to apply
-         * Valid values: "regex", "wildcard", "prefix", "suffix", "exact"
-         */
-        patternType?: string;
-        parentDomainId?: string;
-        description?: string;
-        isActive?: string;
-        createdAt?: string;
-        updatedAt?: string;
-    };
-}
-//# sourceMappingURL=types.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/schema/domain/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAEnD;;;GAGG;AACH,MAAM,WAAW,kBAAmB,SAAQ,kBAAkB;IAC7D,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG;QACjC,EAAE,CAAC,EAAE,MAAM,CAAC;QACZ,MAAM,EAAE,MAAM,CAAC;QACf;;;WAGG;QACH,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB;;;WAGG;QACH,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,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"}