@daiso-tech/core/dist/circuit-breaker/implementations/adapters/kysely-circuit-breaker-storage-adapter/kysely-circuit-breaker-storage-adapter.js

The library offers flexible, framework-agnostic solutions for modern web applications, built on adaptable components that integrate seamlessly with popular frameworks like Next Js.

/**
 * @module CircuitBreaker
 */
import { MysqlAdapter, Transaction } from "kysely";
import {} from "../../../../circuit-breaker/contracts/_module.js";
import {} from "../../../../execution-context/contracts/_module.js";
import {} from "../../../../serde/contracts/_module.js";
import {} from "../../../../utilities/_module.js";
/**
 * @internal
 */
async function find(key, { serde, kysely }) {
    const row = await kysely
        .selectFrom("circuitBreaker")
        .where("circuitBreaker.key", "=", key)
        .select("circuitBreaker.state")
        .executeTakeFirst();
    if (row === undefined) {
        return null;
    }
    return serde.deserialize(row.state);
}
/**
 * @internal
 */
class KyselyCircuitBreakerStorageAdapterTransaction {
    kysely;
    serde;
    isMysql;
    constructor(settings) {
        const { kysely, serde } = settings;
        this.kysely = kysely;
        this.serde = serde;
        this.isMysql =
            this.kysely.getExecutor().adapter instanceof MysqlAdapter;
    }
    async upsert(_context, key, state) {
        const serializedState = this.serde.serialize(state);
        await this.kysely
            .insertInto("circuitBreaker")
            .values({
            key,
            state: serializedState,
        })
            .$if(!this.isMysql, (eb) => eb.onConflict((eb_) => eb_.column("key").doUpdateSet({
            state: serializedState,
        })))
            .$if(this.isMysql, (eb) => eb.onDuplicateKeyUpdate({
            state: serializedState,
        }))
            .execute();
    }
    async find(_context, key) {
        return find(key, {
            serde: this.serde,
            kysely: this.kysely,
        });
    }
}
/**
 * To utilize the `KyselyCircuitBreakerStorageAdapter`, you must install the [`"kysely"`](https://www.npmjs.com/package/kysely) package and configure a `Kysely` class instance.
 *
 * Note in order to use `KyselyCircuitBreakerStorageAdapter` correctly, you need to use a database that has support for transactions.
 * The adapter have been tested with `sqlite`, `postgres` and `mysql` databases.
 *
 * IMPORT_PATH: `"@daiso-tech/core/circuit-breaker/kysely-circuit-breaker-storage-adapter"`
 * @group Adapters
 */
export class KyselyCircuitBreakerStorageAdapter {
    kysely;
    serde;
    enableTransactions;
    /**
     * @example
     * ```ts
     * import { KyselyCircuitBreakerStorageAdapter } from "@daiso-tech/core/circuit-breaker/kysely-circuit-breaker-storage-adapter";
     * import { Serde } from "@daiso-tech/core/serde";
     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/super-json-serde-adapter"
     * import Sqlite from "better-sqlite3";
     * import { Kysely, SqliteDialect } from "kysely";
     *
     * const serde = new Serde(new SuperJsonSerdeAdapter());
     * const circuitBreakerStorageAdapter = new KyselyCircuitBreakerStorageAdapter({
     *   kysely: new Kysely({
     *     dialect: new SqliteDialect({
     *       database: new Sqlite("local.db"),
     *     }),
     *   }),
     *   serde
     * });
     * // You need initialize the adapter once before using it.
     * await circuitBreakerStorageAdapter.init();
     * ```
     */
    constructor(settings) {
        const { kysely, serde, enableTransactions = !(settings.kysely instanceof Transaction), } = settings;
        this.kysely = kysely;
        this.serde = serde;
        this.enableTransactions = enableTransactions;
    }
    _transaction(trxFn) {
        if (this.enableTransactions) {
            return this.kysely.transaction().execute(async (trx) => {
                return await trxFn(trx);
            });
        }
        return trxFn(this.kysely);
    }
    /**
     * Removes all related circuit breaker tables and their rows.
     * Note all circuit breaker data will be removed.
     */
    async deInit() {
        // Should throw if the table does not exists thats why the try catch is used.
        try {
            await this.kysely.schema.dropTable("circuitBreaker").execute();
        }
        catch {
            /* EMPTY */
        }
    }
    /**
     * Creates all related tables and indexes.
     * Note the `init` method needs to be called once before using the adapter.
     */
    async init() {
        // Should throw if the table already exists thats why the try catch is used.
        try {
            await this.kysely.schema
                .createTable("circuitBreaker")
                .addColumn("key", "varchar(255)", (col) => col.primaryKey().notNull())
                .addColumn("state", "varchar(255)", (col) => col.notNull())
                .execute();
        }
        catch {
            /* EMPTY */
        }
    }
    async transaction(_context, fn) {
        return await this._transaction(async (trx) => {
            return await fn(new KyselyCircuitBreakerStorageAdapterTransaction({
                kysely: trx,
                serde: this.serde,
            }));
        });
    }
    async find(_context, key) {
        return find(key, {
            serde: this.serde,
            kysely: this.kysely,
        });
    }
    async remove(_context, key) {
        await this.kysely
            .deleteFrom("circuitBreaker")
            .where("circuitBreaker.key", "=", key)
            .execute();
    }
}
//# sourceMappingURL=kysely-circuit-breaker-storage-adapter.js.map