@c15t/backend 0.0.1-rc.10

package/dist/db/adapters/kysely-adapter/dialect.d.ts

@@ -0,0 +1,72 @@
+import { Kysely } from 'kysely';
+import type { C15TOptions } from '../../../types';
+import type { Database, KyselyDatabaseType } from './types';
+/**
+ * Creates a Kysely adapter from the provided configuration
+ *
+ * This function analyzes the database configuration in C15TOptions and creates
+ * an appropriate Kysely instance with the correct dialect. It handles several
+ * different configuration formats including:
+ * - Direct Kysely instances
+ * - Dialect configurations
+ * - Raw database connections (SQLite, MySQL, PostgreSQL)
+ * - Kysely dialect instances
+ *
+ * @param config - The C15T configuration options containing database settings
+ * @returns An object containing the initialized Kysely instance and database type
+ *
+ * @example
+ * ```typescript
+ * // Using with a pre-configured Kysely instance
+ * import { Kysely, PostgresDialect } from 'kysely';
+ * import { Pool } from 'pg';
+ * import { c15tInstance } from '@c15t/backend';
+ *
+ * // Create a Postgres connection pool
+ * const pool = new Pool({
+ *   host: 'localhost',
+ *   database: 'consent_db',
+ *   user: 'postgres',
+ *   password: 'password'
+ * });
+ *
+ * // Create Kysely instance
+ * const db = new Kysely({
+ *   dialect: new PostgresDialect({ pool })
+ * });
+ *
+ * // Use in c15t configuration
+ * const c15t = c15tInstance({
+ *   secret: process.env.SECRET_KEY,
+ *   database: { db, type: 'postgres' } // Pre-configured Kysely instance
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using with a direct connection pool
+ * import { Pool } from 'pg';
+ * import { c15tInstance } from '@c15t/backend';
+ *
+ * // Create a Postgres connection pool
+ * const pool = new Pool({
+ *   host: 'localhost',
+ *   database: 'consent_db',
+ *   user: 'postgres',
+ *   password: 'password'
+ * });
+ *
+ * // Pass the pool directly to c15t
+ * const c15t = c15tInstance({
+ *   secret: process.env.SECRET_KEY,
+ *   database: pool // The adapter will detect it's a Postgres pool
+ * });
+ * ```
+ *
+ * @throws {Error} Will throw an error if the database configuration is invalid or if a connection cannot be established
+ */
+export declare const createKyselyAdapter: (config: C15TOptions) => Promise<{
+    kysely: Kysely<Database> | null;
+    databaseType: KyselyDatabaseType | null;
+}>;
+//# sourceMappingURL=dialect.d.ts.map

package/dist/db/adapters/kysely-adapter/dialect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dialect.d.ts","sourceRoot":"","sources":["../../../../src/db/adapters/kysely-adapter/dialect.ts"],"names":[],"mappings":"AAAA,OAAO,EAEN,MAAM,EAKN,MAAM,QAAQ,CAAC;AAChB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAC3C,OAAO,KAAK,EACX,QAAQ,EAGR,kBAAkB,EAElB,MAAM,SAAS,CAAC;AAmDjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,eAAO,MAAM,mBAAmB,GAC/B,QAAQ,WAAW,KACjB,OAAO,CAAC;IACV,MAAM,EAAE,MAAM,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC;IAChC,YAAY,EAAE,kBAAkB,GAAG,IAAI,CAAC;CACxC,CAwDA,CAAC"}

package/dist/db/adapters/kysely-adapter/index.d.ts

@@ -0,0 +1,4 @@
+export * from './dialect';
+export * from './types';
+export * from './kysely-adapter';
+//# sourceMappingURL=index.d.ts.map

package/dist/db/adapters/kysely-adapter/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/db/adapters/kysely-adapter/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AACxB,cAAc,kBAAkB,CAAC"}

package/dist/db/adapters/kysely-adapter/kysely-adapter.d.ts

@@ -0,0 +1,98 @@
+import type { Kysely } from 'kysely';
+import type { EntityName, EntityTypeMap } from '../../core/types';
+import type { C15TOptions } from '../../../types';
+import type { Adapter } from '../types';
+import type { Database, KyselyDatabaseType } from './types';
+/**
+ * Interface for where conditions in Kysely queries
+ *
+ * This interface defines the structure of query conditions used
+ * in database operations. It supports various operators and connectors
+ * for building complex query conditions.
+ *
+ * @typeParam EntityType - The entity type being queried
+ */
+export interface WhereCondition<EntityType extends EntityName> {
+    /**
+     * The field to apply the condition to
+     */
+    field: keyof EntityTypeMap[EntityType] | 'id';
+    /**
+     * The value to compare against
+     */
+    value: unknown;
+    /**
+     * The operator to use for comparison
+     *
+     * @default "="
+     */
+    operator?: 'in' | 'eq' | 'ne' | 'lt' | 'lte' | 'gt' | 'gte' | 'contains' | 'starts_with' | 'ends_with' | 'ilike' | '=';
+    /**
+     * The logical connector to use with previous conditions
+     *
+     * @default "AND"
+     */
+    connector?: 'AND' | 'OR';
+}
+/**
+ * Configuration options for the Kysely adapter
+ *
+ * @example
+ * ```typescript
+ * const config: KyselyAdapterConfig = {
+ *   type: 'postgres' // Explicitly set the database type
+ * };
+ * ```
+ */
+export interface KyselyAdapterConfig {
+    /**
+     * Database type to use with the adapter
+     *
+     * Setting this explicitly can override the auto-detected type
+     * and can be necessary in some environments where detection fails.
+     */
+    type?: KyselyDatabaseType;
+}
+/**
+ * Creates a c15t adapter for Kysely ORM
+ *
+ * This factory function creates an adapter that allows c15t to use Kysely ORM
+ * as its database layer. It supports PostgreSQL, MySQL, SQLite, and MSSQL.
+ *
+ * @param db - The Kysely database instance
+ * @param config - Optional configuration for the Kysely adapter
+ * @returns A c15t adapter factory function
+ *
+ * @example
+ * ```typescript
+ * import { Kysely, PostgresDialect } from 'kysely';
+ * import { Pool } from 'pg';
+ * import { c15tInstance } from '@c15t/backend';
+ * import { kyselyAdapter } from '@c15t/adapters/kysely';
+ *
+ * // Create a Postgres connection pool
+ * const pool = new Pool({
+ *   host: 'localhost',
+ *   database: 'consent_db',
+ *   user: 'postgres',
+ *   password: 'password'
+ * });
+ *
+ * // Create Kysely instance
+ * const db = new Kysely({
+ *   dialect: new PostgresDialect({ pool })
+ * });
+ *
+ * // Create the c15t instance with Kysely adapter
+ * const c15t = c15tInstance({
+ *   storage: kyselyAdapter(db, { type: 'postgres' }),
+ *   // Other c15t options...
+ *   secret: process.env.SECRET
+ * });
+ *
+ * // Use in your application
+ * export default c15tInstance.handler;
+ * ```
+ */
+export declare const kyselyAdapter: (db: Kysely<Database>, config?: KyselyAdapterConfig) => (opts: C15TOptions) => Adapter;
+//# sourceMappingURL=kysely-adapter.d.ts.map

package/dist/db/adapters/kysely-adapter/kysely-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kysely-adapter.d.ts","sourceRoot":"","sources":["../../../../src/db/adapters/kysely-adapter/kysely-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAKX,MAAM,EAKN,MAAM,QAAQ,CAAC;AAShB,OAAO,KAAK,EAEX,UAAU,EAEV,aAAa,EACb,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,KAAK,EAAE,OAAO,EAAsB,MAAM,UAAU,CAAC;AAE5D,OAAO,KAAK,EAAE,QAAQ,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAqB5D;;;;;;;;GAQG;AACH,MAAM,WAAW,cAAc,CAAC,UAAU,SAAS,UAAU;IAC5D;;OAEG;IACH,KAAK,EAAE,MAAM,aAAa,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC;IAE9C;;OAEG;IACH,KAAK,EAAE,OAAO,CAAC;IAEf;;;;OAIG;IACH,QAAQ,CAAC,EACN,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,KAAK,GACL,IAAI,GACJ,KAAK,GACL,UAAU,GACV,aAAa,GACb,WAAW,GACX,OAAO,GACP,GAAG,CAAC;IAEP;;;;OAIG;IACH,SAAS,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC;CACzB;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,mBAAmB;IACnC;;;;;OAKG;IACH,IAAI,CAAC,EAAE,kBAAkB,CAAC;CAC1B;AAydD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,eAAO,MAAM,aAAa,GACxB,IAAI,MAAM,CAAC,QAAQ,CAAC,EAAE,SAAS,mBAAmB,MAClD,MAAM,WAAW,KAAG,OAwhBpB,CAAC"}

package/dist/db/adapters/kysely-adapter/types.d.ts

@@ -0,0 +1,281 @@
+import type { Database as SQLiteDatabase } from 'better-sqlite3';
+import type { Dialect, Kysely, MysqlPool, PostgresPool } from 'kysely';
+import type { Database as KyselyDatabase } from './types';
+import type { AdapterInstance } from '../types';
+import type { EntityTypeMap } from '../../core/types';
+/**
+ * Database interface for Kysely that uses the EntityTypeMap
+ * to ensure all table names and record types are properly typed.
+ *
+ * This allows Kysely operations to be type-safe throughout the adapter.
+ *
+ * @remarks
+ * The Database interface is extended from EntityTypeMap, which contains
+ * all the entity types defined in your c15t configuration. This provides
+ * strong typing for database operations across the entire adapter.
+ *
+ * @example
+ * ```typescript
+ * // The interface is used internally by the adapter to provide
+ * // type safety for database operations
+ * const query = db
+ *   .selectFrom('consent')  // Type-safe table name
+ *   .select(['id', 'subjectId', 'purposeId']) // Type-safe column names
+ *   .where('subjectId', '=', subjectId)
+ *   .executeTakeFirst();
+ * ```
+ */
+export interface Database extends EntityTypeMap {
+    /**
+     * Migration history table used by the adapter to track schema changes
+     */
+    migrations: {
+        id: string;
+        name: string;
+        applied_at: Date;
+        batch: number;
+    };
+    /**
+     * Temporary tables used during migrations
+     * These are created and dropped during the migration process
+     */
+    _migration_temp: {
+        id: string;
+        table_name: string;
+        created_at: Date;
+    };
+}
+/**
+ * Database types supported by the Kysely adapter
+ *
+ * These represent the major SQL database engines that can be used with the adapter.
+ *
+ * @example
+ * ```typescript
+ * // Explicitly specify the database type when creating an adapter
+ * const adapter = kyselyAdapter(db, { type: 'postgres' });
+ * ```
+ */
+export type KyselyDatabaseType = 'postgres' | 'mysql' | 'sqlite' | 'mssql';
+/**
+ * Type alias for PostgreSQL connection pool configuration
+ *
+ * Used when configuring a PostgreSQL database connection.
+ *
+ * @see {@link https://node-postgres.com/apis/pool | PostgreSQL Pool documentation}
+ *
+ * @example
+ * ```typescript
+ * import { Pool } from 'pg';
+ *
+ * // Create a PostgreSQL connection pool
+ * const pool: PostgresPoolConfig = new Pool({
+ *   host: 'localhost',
+ *   database: 'consent_db',
+ *   user: 'postgres',
+ *   password: 'password'
+ * });
+ * ```
+ */
+export type PostgresPoolConfig = PostgresPool;
+/**
+ * Type alias for MySQL connection pool configuration
+ *
+ * Used when configuring a MySQL database connection.
+ *
+ * @see {@link https://github.com/sidorares/node-mysql2#using-connection-pools | MySQL Pool documentation}
+ *
+ * @example
+ * ```typescript
+ * import mysql from 'mysql2';
+ *
+ * // Create a MySQL connection pool
+ * const pool: MysqlPoolConfig = mysql.createPool({
+ *   host: 'localhost',
+ *   user: 'user',
+ *   database: 'consent_db',
+ *   password: 'password',
+ *   waitForConnections: true,
+ *   connectionLimit: 10,
+ *   queueLimit: 0
+ * });
+ * ```
+ */
+export type MysqlPoolConfig = MysqlPool;
+/**
+ * Type alias for SQLite database configuration
+ *
+ * Used when configuring a SQLite database connection.
+ *
+ * @see {@link https://github.com/WiseLibs/better-sqlite3/blob/master/docs/api.md | Better-SQLite3 documentation}
+ *
+ * @example
+ * ```typescript
+ * import Database from 'better-sqlite3';
+ *
+ * // Create a SQLite database connection
+ * const db: SQLiteDatabaseConfig = new Database('consent.db', {
+ *   readonly: false,
+ *   fileMustExist: false
+ * });
+ * ```
+ */
+export type SQLiteDatabaseConfig = SQLiteDatabase;
+/**
+ * Configuration for a Kysely dialect
+ *
+ * This interface allows direct configuration of a Kysely dialect
+ * with explicit type information.
+ *
+ * @example
+ * ```typescript
+ * import { PostgresDialect } from 'kysely';
+ * import { Pool } from 'pg';
+ * import { c15tInstance } from '@c15t/backend';
+ *
+ * // Create a PostgreSQL connection pool
+ * const pool = new Pool({
+ *   host: 'localhost',
+ *   database: 'consent_db'
+ * });
+ *
+ * // Create a dialect config
+ * const dialectConfig: DialectConfig = {
+ *   dialect: new PostgresDialect({ pool }),
+ *   type: 'postgres',
+ *   casing: 'camel'
+ * };
+ *
+ * // Use in c15t configuration
+ * const c15t = c15tInstance({
+ *   storage: kyselyAdapter(dialectConfig),
+ *   secret: process.env.SECRET_KEY
+ * });
+ * ```
+ */
+export interface DialectConfig {
+    /**
+     * The Kysely dialect instance to use for database operations
+     *
+     * @see {@link https://kysely.dev/docs/dialects | Kysely dialects documentation}
+     */
+    dialect: Dialect;
+    /**
+     * The type of database being connected to
+     *
+     * This is used by the adapter to adjust query behavior for different database engines.
+     */
+    type: KyselyDatabaseType;
+    /**
+     * Casing style for table names in the database
+     *
+     * This affects how table names are transformed when interacting with the database.
+     * For example, with 'camel' casing, 'subjectProfile' becomes 'subject_profile' in the database.
+     * With 'snake' casing, it remains as 'subject_profile'.
+     *
+     * @default "camel"
+     */
+    casing?: 'snake' | 'camel';
+    /**
+     * Whether to apply the casing transformation to column names as well
+     *
+     * When true, column names will be transformed according to the casing setting.
+     * When false, column names will remain in their original case.
+     *
+     * @default true
+     */
+    applyCasingToColumns?: boolean;
+}
+/**
+ * Configuration for an existing Kysely instance
+ *
+ * This allows using a pre-configured Kysely instance with the adapter.
+ *
+ * @example
+ * ```typescript
+ * import { Kysely, PostgresDialect } from 'kysely';
+ * import { Pool } from 'pg';
+ * import { c15tInstance } from '@c15t/backend';
+ *
+ * // Create a Postgres connection pool
+ * const pool = new Pool({
+ *   host: 'localhost',
+ *   database: 'consent_db'
+ * });
+ *
+ * // Create a Kysely instance
+ * const db = new Kysely<Database>({
+ *   dialect: new PostgresDialect({ pool })
+ * });
+ *
+ * // Use the pre-configured instance
+ * const config: KyselyInstanceConfig = {
+ *   db,
+ *   type: 'postgres',
+ *   casing: 'camel'
+ * };
+ *
+ * // Pass to c15t configuration
+ * const c15t = c15tInstance({
+ *   storage: kyselyAdapter(config),
+ *   secret: process.env.SECRET_KEY
+ * });
+ * ```
+ */
+export interface KyselyInstanceConfig {
+    /**
+     * Pre-configured Kysely instance to use for database operations
+     *
+     * This should be a fully initialized Kysely instance with the correct
+     * dialect and configuration for your database.
+     */
+    db: Kysely<KyselyDatabase>;
+    /**
+     * The type of database the Kysely instance is connected to
+     *
+     * This is used to adjust query behavior for different database engines.
+     */
+    type: KyselyDatabaseType;
+    /**
+     * Casing style for table names in the database
+     *
+     * This affects how table names are transformed when interacting with the database.
+     * For example, with 'camel' casing, 'subjectProfile' becomes 'subject_profile' in the database.
+     * With 'snake' casing, it remains as 'subject_profile'.
+     *
+     * @default "camel"
+     */
+    casing?: 'snake' | 'camel';
+    /**
+     * Whether to apply the casing transformation to column names as well
+     *
+     * When true, column names will be transformed according to the casing setting.
+     * When false, column names will remain in their original case.
+     *
+     * @default true
+     */
+    applyCasingToColumns?: boolean;
+}
+/**
+ * Union type representing all possible database configurations
+ *
+ * This comprehensive type allows various ways to configure the database:
+ * - Direct connection pools (PostgreSQL, MySQL)
+ * - SQLite database instance
+ * - Kysely dialect
+ * - Custom adapter instance
+ * - Dialect configuration
+ * - Kysely instance configuration
+ *
+ * @remarks
+ * This flexible approach allows you to use the configuration pattern that
+ * works best for your application. You can pass direct database connections,
+ * pre-configured Kysely instances, or dialect configurations.
+ *
+ * @see {@link kyselyAdapter} The function that consumes this configuration
+ */
+export type DatabaseConfiguration = PostgresPoolConfig | MysqlPoolConfig | SQLiteDatabaseConfig | Dialect | AdapterInstance | DialectConfig | KyselyInstanceConfig | {
+    provider: string;
+    options: DatabaseConfiguration;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/db/adapters/kysely-adapter/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/db/adapters/kysely-adapter/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,IAAI,cAAc,EAAE,MAAM,gBAAgB,CAAC;AACjE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACvE,OAAO,KAAK,EAAE,QAAQ,IAAI,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACrF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,QAAS,SAAQ,aAAa;IAK9C;;OAEG;IACH,UAAU,EAAE;QACX,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,UAAU,EAAE,IAAI,CAAC;QACjB,KAAK,EAAE,MAAM,CAAC;KACd,CAAC;IAEF;;;OAGG;IACH,eAAe,EAAE;QAChB,EAAE,EAAE,MAAM,CAAC;QACX,UAAU,EAAE,MAAM,CAAC;QACnB,UAAU,EAAE,IAAI,CAAC;KACjB,CAAC;CACF;AAED;;;;;;;;;;GAUG;AACH,MAAM,MAAM,kBAAkB,GAAG,UAAU,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,CAAC;AAE3E;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,kBAAkB,GAAG,YAAY,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,MAAM,eAAe,GAAG,SAAS,CAAC;AAExC;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,oBAAoB,GAAG,cAAc,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,WAAW,aAAa;IAC7B;;;;OAIG;IACH,OAAO,EAAE,OAAO,CAAC;IAEjB;;;;OAIG;IACH,IAAI,EAAE,kBAAkB,CAAC;IAEzB;;;;;;;;OAQG;IACH,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC;IAE3B;;;;;;;OAOG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,WAAW,oBAAoB;IACpC;;;;;OAKG;IACH,EAAE,EAAE,MAAM,CAAC,cAAc,CAAC,CAAC;IAE3B;;;;OAIG;IACH,IAAI,EAAE,kBAAkB,CAAC;IAEzB;;;;;;;;OAQG;IACH,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC;IAE3B;;;;;;;OAOG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,qBAAqB,GAC9B,kBAAkB,GAClB,eAAe,GACf,oBAAoB,GACpB,OAAO,GACP,eAAe,GACf,aAAa,GACb,oBAAoB,GACpB;IACA,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,qBAAqB,CAAC;CAC9B,CAAC"}