@uql/core 1.0.12 → 3.1.0

package/dist/querier/decorator/injectQuerier.js

@@ -0,0 +1,33 @@
+const metadataKey = Symbol('InjectQuerier');
+export function InjectQuerier() {
+    return (proto, key, index) => {
+        if (!proto[metadataKey]) {
+            proto[metadataKey] = new WeakMap();
+        }
+        if (!proto[metadataKey].has(proto.constructor)) {
+            proto[metadataKey].set(proto.constructor, {});
+        }
+        const meta = proto[metadataKey].get(proto.constructor);
+        const isAlreadyInjected = key in meta;
+        if (isAlreadyInjected) {
+            throw new TypeError(`@InjectQuerier() can only appears once in '${proto.constructor.name}.${key}'}`);
+        }
+        meta[key] = index;
+    };
+}
+export function getInjectedQuerierIndex(service, key) {
+    let proto = service.prototype;
+    while (proto.constructor !== Object) {
+        const meta = proto[metadataKey]?.get(proto.constructor);
+        if (meta && key in meta) {
+            return meta[key];
+        }
+        const keys = Object.getOwnPropertyNames(proto);
+        const isOwnKey = keys.includes(key);
+        if (isOwnKey) {
+            return;
+        }
+        proto = Object.getPrototypeOf(proto);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/querier/decorator/serialized.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Decorator that ensures the decorated method is executed serially within the Querier instance.
+ * It uses a private promise queue to prevent race conditions on the database connection.
+ * Note: The decorated class must extend AbstractQuerier or implement a compatible serialize method.
+ */
+export declare function Serialized(): (_target: object, _key: string, propDescriptor: PropertyDescriptor) => void;

package/dist/querier/decorator/serialized.js

@@ -0,0 +1,14 @@
+/**
+ * Decorator that ensures the decorated method is executed serially within the Querier instance.
+ * It uses a private promise queue to prevent race conditions on the database connection.
+ * Note: The decorated class must extend AbstractQuerier or implement a compatible serialize method.
+ */
+export function Serialized() {
+    return (_target, _key, propDescriptor) => {
+        const originalMethod = propDescriptor.value;
+        propDescriptor.value = function (...args) {
+            return this.serialize(() => originalMethod.apply(this, args));
+        };
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VyaWFsaXplZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9xdWVyaWVyL2RlY29yYXRvci9zZXJpYWxpemVkLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUc7QUFDSCxNQUFNLFVBQVUsVUFBVTtJQUN4QixPQUFPLENBQUMsT0FBZSxFQUFFLElBQVksRUFBRSxjQUFrQyxFQUFRLEVBQUU7UUFDakYsTUFBTSxjQUFjLEdBQUcsY0FBYyxDQUFDLEtBQUssQ0FBQztRQUM1QyxjQUFjLENBQUMsS0FBSyxHQUFHLFVBQXFCLEdBQUcsSUFBVztZQUN4RCxPQUFPLElBQUksQ0FBQyxTQUFTLENBQUMsR0FBRyxFQUFFLENBQUMsY0FBYyxDQUFDLEtBQUssQ0FBQyxJQUFJLEVBQUUsSUFBSSxDQUFDLENBQUMsQ0FBQztRQUNoRSxDQUFDLENBQUM7SUFDSixDQUFDLENBQUM7QUFDSixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBEZWNvcmF0b3IgdGhhdCBlbnN1cmVzIHRoZSBkZWNvcmF0ZWQgbWV0aG9kIGlzIGV4ZWN1dGVkIHNlcmlhbGx5IHdpdGhpbiB0aGUgUXVlcmllciBpbnN0YW5jZS5cbiAqIEl0IHVzZXMgYSBwcml2YXRlIHByb21pc2UgcXVldWUgdG8gcHJldmVudCByYWNlIGNvbmRpdGlvbnMgb24gdGhlIGRhdGFiYXNlIGNvbm5lY3Rpb24uXG4gKiBOb3RlOiBUaGUgZGVjb3JhdGVkIGNsYXNzIG11c3QgZXh0ZW5kIEFic3RyYWN0UXVlcmllciBvciBpbXBsZW1lbnQgYSBjb21wYXRpYmxlIHNlcmlhbGl6ZSBtZXRob2QuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBTZXJpYWxpemVkKCkge1xuICByZXR1cm4gKF90YXJnZXQ6IG9iamVjdCwgX2tleTogc3RyaW5nLCBwcm9wRGVzY3JpcHRvcjogUHJvcGVydHlEZXNjcmlwdG9yKTogdm9pZCA9PiB7XG4gICAgY29uc3Qgb3JpZ2luYWxNZXRob2QgPSBwcm9wRGVzY3JpcHRvci52YWx1ZTtcbiAgICBwcm9wRGVzY3JpcHRvci52YWx1ZSA9IGZ1bmN0aW9uICh0aGlzOiBhbnksIC4uLmFyZ3M6IGFueVtdKSB7XG4gICAgICByZXR1cm4gdGhpcy5zZXJpYWxpemUoKCkgPT4gb3JpZ2luYWxNZXRob2QuYXBwbHkodGhpcywgYXJncykpO1xuICAgIH07XG4gIH07XG59XG4iXX0=

package/{querier → dist/querier}/decorator/transactional.d.ts

@@ -1,4 +1,4 @@
-import { QuerierPool } from '../../type';
+import type { QuerierPool } from '../../type/index.js';
 export declare function Transactional({ propagation, querierPool, }?: {
     readonly propagation?: 'supported' | 'required';
     readonly querierPool?: QuerierPool;

package/dist/querier/decorator/transactional.js

@@ -0,0 +1,48 @@
+import { getQuerierPool } from '../../options.js';
+import { getInjectedQuerierIndex } from './injectQuerier.js';
+export function Transactional({ propagation = 'required', querierPool, } = {}) {
+    return (target, key, propDescriptor) => {
+        const theClass = target.constructor;
+        const originalMethod = propDescriptor.value;
+        const injectedQuerierIndex = getInjectedQuerierIndex(theClass, key);
+        if (injectedQuerierIndex === undefined) {
+            throw TypeError(`missing decorator @InjectQuerier() in '${target.constructor.name}.${key}'`);
+        }
+        propDescriptor.value = async function func(...args) {
+            const params = [...args];
+            let isOwnTransaction;
+            let querier;
+            if (params[injectedQuerierIndex]) {
+                querier = params[injectedQuerierIndex];
+            }
+            else {
+                isOwnTransaction = true;
+                const pool = querierPool ?? getQuerierPool();
+                querier = await pool.getQuerier();
+                params[injectedQuerierIndex] = querier;
+            }
+            try {
+                if (propagation === 'required' && !querier.hasOpenTransaction) {
+                    await querier.beginTransaction();
+                }
+                const resp = await originalMethod.apply(this, params);
+                if (isOwnTransaction && querier.hasOpenTransaction) {
+                    await querier.commitTransaction();
+                }
+                return resp;
+            }
+            catch (err) {
+                if (isOwnTransaction && querier.hasOpenTransaction) {
+                    await querier.rollbackTransaction();
+                }
+                throw err;
+            }
+            finally {
+                if (isOwnTransaction) {
+                    await querier.release();
+                }
+            }
+        };
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/querier/index.d.ts

@@ -0,0 +1,4 @@
+export * from './abstractQuerier.js';
+export * from './abstractQuerierPool.js';
+export * from './abstractSqlQuerier.js';
+export * from './decorator/index.js';

package/dist/querier/index.js

@@ -0,0 +1,5 @@
+export * from './abstractQuerier.js';
+export * from './abstractQuerierPool.js';
+export * from './abstractSqlQuerier.js';
+export * from './decorator/index.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcXVlcmllci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLHNCQUFzQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9hYnN0cmFjdFF1ZXJpZXIuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9hYnN0cmFjdFF1ZXJpZXJQb29sLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vYWJzdHJhY3RTcWxRdWVyaWVyLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vZGVjb3JhdG9yL2luZGV4LmpzJztcbiJdfQ==

package/dist/repository/genericRepository.d.ts

@@ -0,0 +1,20 @@
+import type { IdValue, Querier, Query, QueryConflictPaths, QueryOne, QueryOptions, QuerySearch, Repository, Type } from '../type/index.js';
+export declare class GenericRepository<E> implements Repository<E> {
+    readonly entity: Type<E>;
+    readonly querier: Querier;
+    constructor(entity: Type<E>, querier: Querier);
+    findOneById(id: IdValue<E>, q?: QueryOne<E>): Promise<E>;
+    findOne(q: QueryOne<E>): Promise<E>;
+    findMany(q: Query<E>): Promise<E[]>;
+    findManyAndCount(q: Query<E>): Promise<[E[], number]>;
+    count(q?: QuerySearch<E>): Promise<number>;
+    insertOne(payload: E): Promise<IdValue<E>>;
+    upsertOne(conflictPaths: QueryConflictPaths<E>, payload: E): Promise<import("../type/query.js").QueryUpdateResult>;
+    insertMany(payload: E[]): Promise<IdValue<E>[]>;
+    updateOneById(id: IdValue<E>, payload: E): Promise<number>;
+    updateMany(qm: QuerySearch<E>, payload: E): Promise<number>;
+    saveOne(payload: E): Promise<IdValue<E>>;
+    saveMany(payload: E[]): Promise<IdValue<E>[]>;
+    deleteOneById(id: IdValue<E>, opts?: QueryOptions): Promise<number>;
+    deleteMany(qm: QuerySearch<E>, opts?: QueryOptions): Promise<number>;
+}

package/dist/repository/genericRepository.js

@@ -0,0 +1,51 @@
+export class GenericRepository {
+    entity;
+    querier;
+    constructor(entity, querier) {
+        this.entity = entity;
+        this.querier = querier;
+    }
+    findOneById(id, q) {
+        return this.querier.findOneById(this.entity, id, q);
+    }
+    findOne(q) {
+        return this.querier.findOne(this.entity, q);
+    }
+    findMany(q) {
+        return this.querier.findMany(this.entity, q);
+    }
+    findManyAndCount(q) {
+        return this.querier.findManyAndCount(this.entity, q);
+    }
+    count(q) {
+        return this.querier.count(this.entity, q);
+    }
+    insertOne(payload) {
+        return this.querier.insertOne(this.entity, payload);
+    }
+    upsertOne(conflictPaths, payload) {
+        return this.querier.upsertOne(this.entity, conflictPaths, payload);
+    }
+    insertMany(payload) {
+        return this.querier.insertMany(this.entity, payload);
+    }
+    updateOneById(id, payload) {
+        return this.querier.updateOneById(this.entity, id, payload);
+    }
+    updateMany(qm, payload) {
+        return this.querier.updateMany(this.entity, qm, payload);
+    }
+    saveOne(payload) {
+        return this.querier.saveOne(this.entity, payload);
+    }
+    saveMany(payload) {
+        return this.querier.saveMany(this.entity, payload);
+    }
+    deleteOneById(id, opts) {
+        return this.querier.deleteOneById(this.entity, id, opts);
+    }
+    deleteMany(qm, opts) {
+        return this.querier.deleteMany(this.entity, qm, opts);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/repository/index.d.ts

@@ -0,0 +1 @@
+export * from './genericRepository.js';

package/dist/repository/index.js

@@ -0,0 +1,2 @@
+export * from './genericRepository.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcmVwb3NpdG9yeS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHdCQUF3QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9nZW5lcmljUmVwb3NpdG9yeS5qcyc7XG4iXX0=

package/dist/sqlite/index.d.ts

@@ -0,0 +1,3 @@
+export * from './sqliteDialect.js';
+export * from './sqliteQuerier.js';
+export * from './sqliteQuerierPool.js';

package/dist/sqlite/index.js

@@ -0,0 +1,4 @@
+export * from './sqliteDialect.js';
+export * from './sqliteQuerier.js';
+export * from './sqliteQuerierPool.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc3FsaXRlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLHdCQUF3QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9zcWxpdGVEaWFsZWN0LmpzJztcbmV4cG9ydCAqIGZyb20gJy4vc3FsaXRlUXVlcmllci5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3NxbGl0ZVF1ZXJpZXJQb29sLmpzJztcbiJdfQ==

package/dist/sqlite/sqliteDialect.d.ts

@@ -0,0 +1,10 @@
+import { AbstractSqlDialect } from '../dialect/index.js';
+import type { FieldKey, NamingStrategy, QueryComparisonOptions, QueryConflictPaths, QueryContext, QueryWhereFieldOperatorMap, QueryWhereMap, Type } from '../type/index.js';
+export declare class SqliteDialect extends AbstractSqlDialect {
+    constructor(namingStrategy?: NamingStrategy);
+    addValue(values: unknown[], value: unknown): string;
+    compare<E, K extends keyof QueryWhereMap<E>>(ctx: QueryContext, entity: Type<E>, key: K, val: QueryWhereMap<E>[K], opts?: QueryComparisonOptions): void;
+    compareFieldOperator<E, K extends keyof QueryWhereFieldOperatorMap<E>>(ctx: QueryContext, entity: Type<E>, key: FieldKey<E>, op: K, val: QueryWhereFieldOperatorMap<E>[K], opts?: QueryComparisonOptions): void;
+    upsert<E>(ctx: QueryContext, entity: Type<E>, conflictPaths: QueryConflictPaths<E>, payload: E): void;
+    escape(value: unknown): string;
+}

package/dist/sqlite/sqliteDialect.js

@@ -0,0 +1,48 @@
+import sqlstring from 'sqlstring-sqlite';
+import { AbstractSqlDialect } from '../dialect/index.js';
+import { getMeta } from '../entity/index.js';
+export class SqliteDialect extends AbstractSqlDialect {
+    constructor(namingStrategy) {
+        super(namingStrategy, '`', 'BEGIN TRANSACTION');
+    }
+    addValue(values, value) {
+        if (value instanceof Date) {
+            value = value.getTime();
+        }
+        else if (typeof value === 'boolean') {
+            value = value ? 1 : 0;
+        }
+        return super.addValue(values, value);
+    }
+    compare(ctx, entity, key, val, opts) {
+        if (key === '$text') {
+            const meta = getMeta(entity);
+            const search = val;
+            const fields = search.$fields.map((fKey) => {
+                const field = meta.fields[fKey];
+                const columnName = this.resolveColumnName(fKey, field);
+                return this.escapeId(columnName);
+            });
+            const tableName = this.resolveTableName(entity, meta);
+            ctx.append(`${this.escapeId(tableName)} MATCH {${fields.join(' ')}} : `);
+            ctx.addValue(search.$value);
+            return;
+        }
+        super.compare(ctx, entity, key, val, opts);
+    }
+    compareFieldOperator(ctx, entity, key, op, val, opts = {}) {
+        super.compareFieldOperator(ctx, entity, key, op, val, opts);
+    }
+    upsert(ctx, entity, conflictPaths, payload) {
+        const meta = getMeta(entity);
+        const update = this.getUpsertUpdateAssignments(ctx, meta, conflictPaths, payload, (name) => `EXCLUDED.${name}`);
+        const keysStr = this.getUpsertConflictPathsStr(meta, conflictPaths);
+        const onConflict = update ? `DO UPDATE SET ${update}` : 'DO NOTHING';
+        this.insert(ctx, entity, payload);
+        ctx.append(` ON CONFLICT (${keysStr}) ${onConflict}`);
+    }
+    escape(value) {
+        return sqlstring.escape(value);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3FsaXRlRGlhbGVjdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zcWxpdGUvc3FsaXRlRGlhbGVjdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLFNBQVMsTUFBTSxrQkFBa0IsQ0FBQztBQUN6QyxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUN6RCxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFhN0MsTUFBTSxPQUFPLGFBQWMsU0FBUSxrQkFBa0I7SUFDbkQsWUFBWSxjQUErQjtRQUN6QyxLQUFLLENBQUMsY0FBYyxFQUFFLEdBQUcsRUFBRSxtQkFBbUIsQ0FBQyxDQUFDO0lBQ2xELENBQUM7SUFFUSxRQUFRLENBQUMsTUFBaUIsRUFBRSxLQUFjO1FBQ2pELElBQUksS0FBSyxZQUFZLElBQUksRUFBRSxDQUFDO1lBQzFCLEtBQUssR0FBRyxLQUFLLENBQUMsT0FBTyxFQUFFLENBQUM7UUFDMUIsQ0FBQzthQUFNLElBQUksT0FBTyxLQUFLLEtBQUssU0FBUyxFQUFFLENBQUM7WUFDdEMsS0FBSyxHQUFHLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFDeEIsQ0FBQztRQUNELE9BQU8sS0FBSyxDQUFDLFFBQVEsQ0FBQyxNQUFNLEVBQUUsS0FBSyxDQUFDLENBQUM7SUFDdkMsQ0FBQztJQUVRLE9BQU8sQ0FDZCxHQUFpQixFQUNqQixNQUFlLEVBQ2YsR0FBTSxFQUNOLEdBQXdCLEVBQ3hCLElBQTZCO1FBRTdCLElBQUksR0FBRyxLQUFLLE9BQU8sRUFBRSxDQUFDO1lBQ3BCLE1BQU0sSUFBSSxHQUFHLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FBQztZQUM3QixNQUFNLE1BQU0sR0FBRyxHQUFnQyxDQUFDO1lBQ2hELE1BQU0sTUFBTSxHQUFHLE1BQU0sQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLENBQUMsSUFBSSxFQUFFLEVBQUU7Z0JBQ3pDLE1BQU0sS0FBSyxHQUFHLElBQUksQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLENBQUM7Z0JBQ2hDLE1BQU0sVUFBVSxHQUFHLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxJQUFjLEVBQUUsS0FBSyxDQUFDLENBQUM7Z0JBQ2pFLE9BQU8sSUFBSSxDQUFDLFFBQVEsQ0FBQyxVQUFVLENBQUMsQ0FBQztZQUNuQyxDQUFDLENBQUMsQ0FBQztZQUNILE1BQU0sU0FBUyxHQUFHLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxNQUFNLEVBQUUsSUFBSSxDQUFDLENBQUM7WUFDdEQsR0FBRyxDQUFDLE1BQU0sQ0FBQyxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsU0FBUyxDQUFDLFdBQVcsTUFBTSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLENBQUM7WUFDekUsR0FBRyxDQUFDLFFBQVEsQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUM7WUFDNUIsT0FBTztRQUNULENBQUM7UUFDRCxLQUFLLENBQUMsT0FBTyxDQUFDLEdBQUcsRUFBRSxNQUFNLEVBQUUsR0FBRyxFQUFFLEdBQUcsRUFBRSxJQUFJLENBQUMsQ0FBQztJQUM3QyxDQUFDO0lBRVEsb0JBQW9CLENBQzNCLEdBQWlCLEVBQ2pCLE1BQWUsRUFDZixHQUFnQixFQUNoQixFQUFLLEVBQ0wsR0FBcUMsRUFDckMsT0FBK0IsRUFBRTtRQUVqQyxLQUFLLENBQUMsb0JBQW9CLENBQUMsR0FBRyxFQUFFLE1BQU0sRUFBRSxHQUFHLEVBQUUsRUFBRSxFQUFFLEdBQUcsRUFBRSxJQUFJLENBQUMsQ0FBQztJQUM5RCxDQUFDO0lBRVEsTUFBTSxDQUFJLEdBQWlCLEVBQUUsTUFBZSxFQUFFLGFBQW9DLEVBQUUsT0FBVTtRQUNyRyxNQUFNLElBQUksR0FBRyxPQUFPLENBQUMsTUFBTSxDQUFDLENBQUM7UUFDN0IsTUFBTSxNQUFNLEdBQUcsSUFBSSxDQUFDLDBCQUEwQixDQUFDLEdBQUcsRUFBRSxJQUFJLEVBQUUsYUFBYSxFQUFFLE9BQU8sRUFBRSxDQUFDLElBQUksRUFBRSxFQUFFLENBQUMsWUFBWSxJQUFJLEVBQUUsQ0FBQyxDQUFDO1FBQ2hILE1BQU0sT0FBTyxHQUFHLElBQUksQ0FBQyx5QkFBeUIsQ0FBQyxJQUFJLEVBQUUsYUFBYSxDQUFDLENBQUM7UUFDcEUsTUFBTSxVQUFVLEdBQUcsTUFBTSxDQUFDLENBQUMsQ0FBQyxpQkFBaUIsTUFBTSxFQUFFLENBQUMsQ0FBQyxDQUFDLFlBQVksQ0FBQztRQUNyRSxJQUFJLENBQUMsTUFBTSxDQUFDLEdBQUcsRUFBRSxNQUFNLEVBQUUsT0FBTyxDQUFDLENBQUM7UUFDbEMsR0FBRyxDQUFDLE1BQU0sQ0FBQyxpQkFBaUIsT0FBTyxLQUFLLFVBQVUsRUFBRSxDQUFDLENBQUM7SUFDeEQsQ0FBQztJQUVRLE1BQU0sQ0FBQyxLQUFjO1FBQzVCLE9BQU8sU0FBUyxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUNqQyxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgc3Fsc3RyaW5nIGZyb20gJ3NxbHN0cmluZy1zcWxpdGUnO1xuaW1wb3J0IHsgQWJzdHJhY3RTcWxEaWFsZWN0IH0gZnJvbSAnLi4vZGlhbGVjdC9pbmRleC5qcyc7XG5pbXBvcnQgeyBnZXRNZXRhIH0gZnJvbSAnLi4vZW50aXR5L2luZGV4LmpzJztcbmltcG9ydCB0eXBlIHtcbiAgRmllbGRLZXksXG4gIE5hbWluZ1N0cmF0ZWd5LFxuICBRdWVyeUNvbXBhcmlzb25PcHRpb25zLFxuICBRdWVyeUNvbmZsaWN0UGF0aHMsXG4gIFF1ZXJ5Q29udGV4dCxcbiAgUXVlcnlUZXh0U2VhcmNoT3B0aW9ucyxcbiAgUXVlcnlXaGVyZUZpZWxkT3BlcmF0b3JNYXAsXG4gIFF1ZXJ5V2hlcmVNYXAsXG4gIFR5cGUsXG59IGZyb20gJy4uL3R5cGUvaW5kZXguanMnO1xuXG5leHBvcnQgY2xhc3MgU3FsaXRlRGlhbGVjdCBleHRlbmRzIEFic3RyYWN0U3FsRGlhbGVjdCB7XG4gIGNvbnN0cnVjdG9yKG5hbWluZ1N0cmF0ZWd5PzogTmFtaW5nU3RyYXRlZ3kpIHtcbiAgICBzdXBlcihuYW1pbmdTdHJhdGVneSwgJ2AnLCAnQkVHSU4gVFJBTlNBQ1RJT04nKTtcbiAgfVxuXG4gIG92ZXJyaWRlIGFkZFZhbHVlKHZhbHVlczogdW5rbm93bltdLCB2YWx1ZTogdW5rbm93bik6IHN0cmluZyB7XG4gICAgaWYgKHZhbHVlIGluc3RhbmNlb2YgRGF0ZSkge1xuICAgICAgdmFsdWUgPSB2YWx1ZS5nZXRUaW1lKCk7XG4gICAgfSBlbHNlIGlmICh0eXBlb2YgdmFsdWUgPT09ICdib29sZWFuJykge1xuICAgICAgdmFsdWUgPSB2YWx1ZSA/IDEgOiAwO1xuICAgIH1cbiAgICByZXR1cm4gc3VwZXIuYWRkVmFsdWUodmFsdWVzLCB2YWx1ZSk7XG4gIH1cblxuICBvdmVycmlkZSBjb21wYXJlPEUsIEsgZXh0ZW5kcyBrZXlvZiBRdWVyeVdoZXJlTWFwPEU+PihcbiAgICBjdHg6IFF1ZXJ5Q29udGV4dCxcbiAgICBlbnRpdHk6IFR5cGU8RT4sXG4gICAga2V5OiBLLFxuICAgIHZhbDogUXVlcnlXaGVyZU1hcDxFPltLXSxcbiAgICBvcHRzPzogUXVlcnlDb21wYXJpc29uT3B0aW9ucyxcbiAgKTogdm9pZCB7XG4gICAgaWYgKGtleSA9PT0gJyR0ZXh0Jykge1xuICAgICAgY29uc3QgbWV0YSA9IGdldE1ldGEoZW50aXR5KTtcbiAgICAgIGNvbnN0IHNlYXJjaCA9IHZhbCBhcyBRdWVyeVRleHRTZWFyY2hPcHRpb25zPEU+O1xuICAgICAgY29uc3QgZmllbGRzID0gc2VhcmNoLiRmaWVsZHMubWFwKChmS2V5KSA9PiB7XG4gICAgICAgIGNvbnN0IGZpZWxkID0gbWV0YS5maWVsZHNbZktleV07XG4gICAgICAgIGNvbnN0IGNvbHVtbk5hbWUgPSB0aGlzLnJlc29sdmVDb2x1bW5OYW1lKGZLZXkgYXMgc3RyaW5nLCBmaWVsZCk7XG4gICAgICAgIHJldHVybiB0aGlzLmVzY2FwZUlkKGNvbHVtbk5hbWUpO1xuICAgICAgfSk7XG4gICAgICBjb25zdCB0YWJsZU5hbWUgPSB0aGlzLnJlc29sdmVUYWJsZU5hbWUoZW50aXR5LCBtZXRhKTtcbiAgICAgIGN0eC5hcHBlbmQoYCR7dGhpcy5lc2NhcGVJZCh0YWJsZU5hbWUpfSBNQVRDSCB7JHtmaWVsZHMuam9pbignICcpfX0gOiBgKTtcbiAgICAgIGN0eC5hZGRWYWx1ZShzZWFyY2guJHZhbHVlKTtcbiAgICAgIHJldHVybjtcbiAgICB9XG4gICAgc3VwZXIuY29tcGFyZShjdHgsIGVudGl0eSwga2V5LCB2YWwsIG9wdHMpO1xuICB9XG5cbiAgb3ZlcnJpZGUgY29tcGFyZUZpZWxkT3BlcmF0b3I8RSwgSyBleHRlbmRzIGtleW9mIFF1ZXJ5V2hlcmVGaWVsZE9wZXJhdG9yTWFwPEU+PihcbiAgICBjdHg6IFF1ZXJ5Q29udGV4dCxcbiAgICBlbnRpdHk6IFR5cGU8RT4sXG4gICAga2V5OiBGaWVsZEtleTxFPixcbiAgICBvcDogSyxcbiAgICB2YWw6IFF1ZXJ5V2hlcmVGaWVsZE9wZXJhdG9yTWFwPEU+W0tdLFxuICAgIG9wdHM6IFF1ZXJ5Q29tcGFyaXNvbk9wdGlvbnMgPSB7fSxcbiAgKTogdm9pZCB7XG4gICAgc3VwZXIuY29tcGFyZUZpZWxkT3BlcmF0b3IoY3R4LCBlbnRpdHksIGtleSwgb3AsIHZhbCwgb3B0cyk7XG4gIH1cblxuICBvdmVycmlkZSB1cHNlcnQ8RT4oY3R4OiBRdWVyeUNvbnRleHQsIGVudGl0eTogVHlwZTxFPiwgY29uZmxpY3RQYXRoczogUXVlcnlDb25mbGljdFBhdGhzPEU+LCBwYXlsb2FkOiBFKTogdm9pZCB7XG4gICAgY29uc3QgbWV0YSA9IGdldE1ldGEoZW50aXR5KTtcbiAgICBjb25zdCB1cGRhdGUgPSB0aGlzLmdldFVwc2VydFVwZGF0ZUFzc2lnbm1lbnRzKGN0eCwgbWV0YSwgY29uZmxpY3RQYXRocywgcGF5bG9hZCwgKG5hbWUpID0+IGBFWENMVURFRC4ke25hbWV9YCk7XG4gICAgY29uc3Qga2V5c1N0ciA9IHRoaXMuZ2V0VXBzZXJ0Q29uZmxpY3RQYXRoc1N0cihtZXRhLCBjb25mbGljdFBhdGhzKTtcbiAgICBjb25zdCBvbkNvbmZsaWN0ID0gdXBkYXRlID8gYERPIFVQREFURSBTRVQgJHt1cGRhdGV9YCA6ICdETyBOT1RISU5HJztcbiAgICB0aGlzLmluc2VydChjdHgsIGVudGl0eSwgcGF5bG9hZCk7XG4gICAgY3R4LmFwcGVuZChgIE9OIENPTkZMSUNUICgke2tleXNTdHJ9KSAke29uQ29uZmxpY3R9YCk7XG4gIH1cblxuICBvdmVycmlkZSBlc2NhcGUodmFsdWU6IHVua25vd24pOiBzdHJpbmcge1xuICAgIHJldHVybiBzcWxzdHJpbmcuZXNjYXBlKHZhbHVlKTtcbiAgfVxufVxuIl19

package/dist/sqlite/sqliteQuerier.d.ts

@@ -0,0 +1,15 @@
+import type { Database } from 'better-sqlite3';
+import { AbstractSqlQuerier } from '../querier/index.js';
+import type { ExtraOptions } from '../type/index.js';
+export declare class SqliteQuerier extends AbstractSqlQuerier {
+    readonly db: Database;
+    readonly extra?: ExtraOptions;
+    constructor(db: Database, extra?: ExtraOptions);
+    internalAll<T>(query: string, values?: unknown[]): Promise<T[]>;
+    internalRun(query: string, values?: unknown[]): Promise<{
+        changes: number;
+        ids: any[];
+        firstId: number;
+    }>;
+    internalRelease(): Promise<void>;
+}

package/dist/sqlite/sqliteQuerier.js

@@ -0,0 +1,33 @@
+import { AbstractSqlQuerier } from '../querier/index.js';
+import { SqliteDialect } from './sqliteDialect.js';
+export class SqliteQuerier extends AbstractSqlQuerier {
+    db;
+    extra;
+    constructor(db, extra) {
+        super(new SqliteDialect(extra?.namingStrategy));
+        this.db = db;
+        this.extra = extra;
+    }
+    async internalAll(query, values) {
+        this.extra?.logger?.(query, values);
+        return this.db.prepare(query).all(values || []);
+    }
+    async internalRun(query, values) {
+        this.extra?.logger?.(query, values);
+        const { changes, lastInsertRowid } = this.db.prepare(query).run(values || []);
+        const firstId = lastInsertRowid ? Number(lastInsertRowid) - (changes - 1) : undefined;
+        const ids = firstId
+            ? Array(changes)
+                .fill(firstId)
+                .map((i, index) => i + index)
+            : [];
+        return { changes, ids, firstId };
+    }
+    async internalRelease() {
+        if (this.hasOpenTransaction) {
+            throw TypeError('pending transaction');
+        }
+        // no-op
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3FsaXRlUXVlcmllci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zcWxpdGUvc3FsaXRlUXVlcmllci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUV6RCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFbkQsTUFBTSxPQUFPLGFBQWMsU0FBUSxrQkFBa0I7SUFFeEM7SUFDQTtJQUZYLFlBQ1csRUFBWSxFQUNaLEtBQW9CO1FBRTdCLEtBQUssQ0FBQyxJQUFJLGFBQWEsQ0FBQyxLQUFLLEVBQUUsY0FBYyxDQUFDLENBQUMsQ0FBQztRQUh2QyxPQUFFLEdBQUYsRUFBRSxDQUFVO1FBQ1osVUFBSyxHQUFMLEtBQUssQ0FBZTtJQUcvQixDQUFDO0lBRVEsS0FBSyxDQUFDLFdBQVcsQ0FBSSxLQUFhLEVBQUUsTUFBa0I7UUFDN0QsSUFBSSxDQUFDLEtBQUssRUFBRSxNQUFNLEVBQUUsQ0FBQyxLQUFLLEVBQUUsTUFBTSxDQUFDLENBQUM7UUFDcEMsT0FBTyxJQUFJLENBQUMsRUFBRSxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsQ0FBQyxHQUFHLENBQUMsTUFBTSxJQUFJLEVBQUUsQ0FBUSxDQUFDO0lBQ3pELENBQUM7SUFFUSxLQUFLLENBQUMsV0FBVyxDQUFDLEtBQWEsRUFBRSxNQUFrQjtRQUMxRCxJQUFJLENBQUMsS0FBSyxFQUFFLE1BQU0sRUFBRSxDQUFDLEtBQUssRUFBRSxNQUFNLENBQUMsQ0FBQztRQUNwQyxNQUFNLEVBQUUsT0FBTyxFQUFFLGVBQWUsRUFBRSxHQUFHLElBQUksQ0FBQyxFQUFFLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDLEdBQUcsQ0FBQyxNQUFNLElBQUksRUFBRSxDQUFDLENBQUM7UUFDOUUsTUFBTSxPQUFPLEdBQUcsZUFBZSxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsZUFBZSxDQUFDLEdBQUcsQ0FBQyxPQUFPLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLFNBQVMsQ0FBQztRQUN0RixNQUFNLEdBQUcsR0FBRyxPQUFPO1lBQ2pCLENBQUMsQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDO2lCQUNYLElBQUksQ0FBQyxPQUFPLENBQUM7aUJBQ2IsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLEtBQUssRUFBRSxFQUFFLENBQUMsQ0FBQyxHQUFHLEtBQUssQ0FBQztZQUNqQyxDQUFDLENBQUMsRUFBRSxDQUFDO1FBQ1AsT0FBTyxFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUUsT0FBTyxFQUE4QixDQUFDO0lBQy9ELENBQUM7SUFFUSxLQUFLLENBQUMsZUFBZTtRQUM1QixJQUFJLElBQUksQ0FBQyxrQkFBa0IsRUFBRSxDQUFDO1lBQzVCLE1BQU0sU0FBUyxDQUFDLHFCQUFxQixDQUFDLENBQUM7UUFDekMsQ0FBQztRQUNELFFBQVE7SUFDVixDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IERhdGFiYXNlIH0gZnJvbSAnYmV0dGVyLXNxbGl0ZTMnO1xuaW1wb3J0IHsgQWJzdHJhY3RTcWxRdWVyaWVyIH0gZnJvbSAnLi4vcXVlcmllci9pbmRleC5qcyc7XG5pbXBvcnQgdHlwZSB7IEV4dHJhT3B0aW9ucywgUXVlcnlVcGRhdGVSZXN1bHQgfSBmcm9tICcuLi90eXBlL2luZGV4LmpzJztcbmltcG9ydCB7IFNxbGl0ZURpYWxlY3QgfSBmcm9tICcuL3NxbGl0ZURpYWxlY3QuanMnO1xuXG5leHBvcnQgY2xhc3MgU3FsaXRlUXVlcmllciBleHRlbmRzIEFic3RyYWN0U3FsUXVlcmllciB7XG4gIGNvbnN0cnVjdG9yKFxuICAgIHJlYWRvbmx5IGRiOiBEYXRhYmFzZSxcbiAgICByZWFkb25seSBleHRyYT86IEV4dHJhT3B0aW9ucyxcbiAgKSB7XG4gICAgc3VwZXIobmV3IFNxbGl0ZURpYWxlY3QoZXh0cmE/Lm5hbWluZ1N0cmF0ZWd5KSk7XG4gIH1cblxuICBvdmVycmlkZSBhc3luYyBpbnRlcm5hbEFsbDxUPihxdWVyeTogc3RyaW5nLCB2YWx1ZXM/OiB1bmtub3duW10pIHtcbiAgICB0aGlzLmV4dHJhPy5sb2dnZXI/LihxdWVyeSwgdmFsdWVzKTtcbiAgICByZXR1cm4gdGhpcy5kYi5wcmVwYXJlKHF1ZXJ5KS5hbGwodmFsdWVzIHx8IFtdKSBhcyBUW107XG4gIH1cblxuICBvdmVycmlkZSBhc3luYyBpbnRlcm5hbFJ1bihxdWVyeTogc3RyaW5nLCB2YWx1ZXM/OiB1bmtub3duW10pIHtcbiAgICB0aGlzLmV4dHJhPy5sb2dnZXI/LihxdWVyeSwgdmFsdWVzKTtcbiAgICBjb25zdCB7IGNoYW5nZXMsIGxhc3RJbnNlcnRSb3dpZCB9ID0gdGhpcy5kYi5wcmVwYXJlKHF1ZXJ5KS5ydW4odmFsdWVzIHx8IFtdKTtcbiAgICBjb25zdCBmaXJzdElkID0gbGFzdEluc2VydFJvd2lkID8gTnVtYmVyKGxhc3RJbnNlcnRSb3dpZCkgLSAoY2hhbmdlcyAtIDEpIDogdW5kZWZpbmVkO1xuICAgIGNvbnN0IGlkcyA9IGZpcnN0SWRcbiAgICAgID8gQXJyYXkoY2hhbmdlcylcbiAgICAgICAgICAuZmlsbChmaXJzdElkKVxuICAgICAgICAgIC5tYXAoKGksIGluZGV4KSA9PiBpICsgaW5kZXgpXG4gICAgICA6IFtdO1xuICAgIHJldHVybiB7IGNoYW5nZXMsIGlkcywgZmlyc3RJZCB9IHNhdGlzZmllcyBRdWVyeVVwZGF0ZVJlc3VsdDtcbiAgfVxuXG4gIG92ZXJyaWRlIGFzeW5jIGludGVybmFsUmVsZWFzZSgpIHtcbiAgICBpZiAodGhpcy5oYXNPcGVuVHJhbnNhY3Rpb24pIHtcbiAgICAgIHRocm93IFR5cGVFcnJvcigncGVuZGluZyB0cmFuc2FjdGlvbicpO1xuICAgIH1cbiAgICAvLyBuby1vcFxuICB9XG59XG4iXX0=

package/dist/sqlite/sqliteQuerier.test.d.ts

@@ -0,0 +1,5 @@
+import { AbstractSqlQuerierIt } from '../querier/abstractSqlQuerier-test.js';
+export declare class Sqlite3QuerierIt extends AbstractSqlQuerierIt {
+    constructor();
+    beforeEach(): Promise<void>;
+}

package/dist/sqlite/sqliteQuerier.test.js

@@ -0,0 +1,19 @@
+import { AbstractSqlQuerierIt } from '../querier/abstractSqlQuerier-test.js';
+import { createSpec } from '../test/index.js';
+import { Sqlite3QuerierPool } from './sqliteQuerierPool.js';
+export class Sqlite3QuerierIt extends AbstractSqlQuerierIt {
+    constructor() {
+        super(new Sqlite3QuerierPool(':memory:'), 'INTEGER PRIMARY KEY');
+    }
+    async beforeEach() {
+        await super.beforeEach();
+        await Promise.all([
+            this.querier.run('PRAGMA foreign_keys = ON'),
+            this.querier.run('PRAGMA journal_mode = WAL'),
+            this.querier.run('PRAGMA synchronous = normal'),
+            this.querier.run('PRAGMA temp_store = memory'),
+        ]);
+    }
+}
+createSpec(new Sqlite3QuerierIt());
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3FsaXRlUXVlcmllci50ZXN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3NxbGl0ZS9zcWxpdGVRdWVyaWVyLnRlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sdUNBQXVDLENBQUM7QUFDN0UsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQzlDLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBRTVELE1BQU0sT0FBTyxnQkFBaUIsU0FBUSxvQkFBb0I7SUFDeEQ7UUFDRSxLQUFLLENBQUMsSUFBSSxrQkFBa0IsQ0FBQyxVQUFVLENBQUMsRUFBRSxxQkFBcUIsQ0FBQyxDQUFDO0lBQ25FLENBQUM7SUFFUSxLQUFLLENBQUMsVUFBVTtRQUN2QixNQUFNLEtBQUssQ0FBQyxVQUFVLEVBQUUsQ0FBQztRQUN6QixNQUFNLE9BQU8sQ0FBQyxHQUFHLENBQUM7WUFDaEIsSUFBSSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsMEJBQTBCLENBQUM7WUFDNUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsMkJBQTJCLENBQUM7WUFDN0MsSUFBSSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsNkJBQTZCLENBQUM7WUFDL0MsSUFBSSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsNEJBQTRCLENBQUM7U0FDL0MsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztDQUNGO0FBRUQsVUFBVSxDQUFDLElBQUksZ0JBQWdCLEVBQUUsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQWJzdHJhY3RTcWxRdWVyaWVySXQgfSBmcm9tICcuLi9xdWVyaWVyL2Fic3RyYWN0U3FsUXVlcmllci10ZXN0LmpzJztcbmltcG9ydCB7IGNyZWF0ZVNwZWMgfSBmcm9tICcuLi90ZXN0L2luZGV4LmpzJztcbmltcG9ydCB7IFNxbGl0ZTNRdWVyaWVyUG9vbCB9IGZyb20gJy4vc3FsaXRlUXVlcmllclBvb2wuanMnO1xuXG5leHBvcnQgY2xhc3MgU3FsaXRlM1F1ZXJpZXJJdCBleHRlbmRzIEFic3RyYWN0U3FsUXVlcmllckl0IHtcbiAgY29uc3RydWN0b3IoKSB7XG4gICAgc3VwZXIobmV3IFNxbGl0ZTNRdWVyaWVyUG9vbCgnOm1lbW9yeTonKSwgJ0lOVEVHRVIgUFJJTUFSWSBLRVknKTtcbiAgfVxuXG4gIG92ZXJyaWRlIGFzeW5jIGJlZm9yZUVhY2goKSB7XG4gICAgYXdhaXQgc3VwZXIuYmVmb3JlRWFjaCgpO1xuICAgIGF3YWl0IFByb21pc2UuYWxsKFtcbiAgICAgIHRoaXMucXVlcmllci5ydW4oJ1BSQUdNQSBmb3JlaWduX2tleXMgPSBPTicpLFxuICAgICAgdGhpcy5xdWVyaWVyLnJ1bignUFJBR01BIGpvdXJuYWxfbW9kZSA9IFdBTCcpLFxuICAgICAgdGhpcy5xdWVyaWVyLnJ1bignUFJBR01BIHN5bmNocm9ub3VzID0gbm9ybWFsJyksXG4gICAgICB0aGlzLnF1ZXJpZXIucnVuKCdQUkFHTUEgdGVtcF9zdG9yZSA9IG1lbW9yeScpLFxuICAgIF0pO1xuICB9XG59XG5cbmNyZWF0ZVNwZWMobmV3IFNxbGl0ZTNRdWVyaWVySXQoKSk7XG4iXX0=

package/dist/sqlite/sqliteQuerierPool.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { Options } from 'better-sqlite3';
+import { AbstractQuerierPool } from '../querier/index.js';
+import type { ExtraOptions } from '../type/index.js';
+import { SqliteQuerier } from './sqliteQuerier.js';
+export declare class Sqlite3QuerierPool extends AbstractQuerierPool<SqliteQuerier> {
+    readonly filename?: string | Buffer;
+    readonly opts?: Options;
+    private querier;
+    constructor(filename?: string | Buffer, opts?: Options, extra?: ExtraOptions);
+    getQuerier(): Promise<SqliteQuerier>;
+    end(): Promise<void>;
+}

package/dist/sqlite/sqliteQuerierPool.js

@@ -0,0 +1,34 @@
+import { AbstractQuerierPool } from '../querier/index.js';
+import { SqliteQuerier } from './sqliteQuerier.js';
+export class Sqlite3QuerierPool extends AbstractQuerierPool {
+    filename;
+    opts;
+    querier;
+    constructor(filename, opts, extra) {
+        super('sqlite', extra);
+        this.filename = filename;
+        this.opts = opts;
+    }
+    async getQuerier() {
+        if (!this.querier) {
+            let db;
+            if (typeof Bun !== 'undefined') {
+                const { Database } = await import('bun:sqlite');
+                db = new Database(this.filename, this.opts);
+                db.run('PRAGMA journal_mode = WAL');
+            }
+            else {
+                const { default: Database } = await import('better-sqlite3');
+                db = new Database(this.filename, this.opts);
+                db.pragma('journal_mode = WAL');
+            }
+            this.querier = new SqliteQuerier(db, this.extra);
+        }
+        return this.querier;
+    }
+    async end() {
+        await this.querier.db.close();
+        delete this.querier;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3FsaXRlUXVlcmllclBvb2wuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc3FsaXRlL3NxbGl0ZVF1ZXJpZXJQb29sLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBRTFELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUVuRCxNQUFNLE9BQU8sa0JBQW1CLFNBQVEsbUJBQWtDO0lBSTdEO0lBQ0E7SUFKSCxPQUFPLENBQWdCO0lBRS9CLFlBQ1csUUFBMEIsRUFDMUIsSUFBYyxFQUN2QixLQUFvQjtRQUVwQixLQUFLLENBQUMsUUFBUSxFQUFFLEtBQUssQ0FBQyxDQUFDO1FBSmQsYUFBUSxHQUFSLFFBQVEsQ0FBa0I7UUFDMUIsU0FBSSxHQUFKLElBQUksQ0FBVTtJQUl6QixDQUFDO0lBRUQsS0FBSyxDQUFDLFVBQVU7UUFDZCxJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU8sRUFBRSxDQUFDO1lBQ2xCLElBQUksRUFBTyxDQUFDO1lBQ1osSUFBSSxPQUFPLEdBQUcsS0FBSyxXQUFXLEVBQUUsQ0FBQztnQkFDL0IsTUFBTSxFQUFFLFFBQVEsRUFBRSxHQUFHLE1BQU0sTUFBTSxDQUFDLFlBQVksQ0FBQyxDQUFDO2dCQUNoRCxFQUFFLEdBQUcsSUFBSSxRQUFRLENBQUMsSUFBSSxDQUFDLFFBQWtCLEVBQUUsSUFBSSxDQUFDLElBQVcsQ0FBQyxDQUFDO2dCQUM3RCxFQUFFLENBQUMsR0FBRyxDQUFDLDJCQUEyQixDQUFDLENBQUM7WUFDdEMsQ0FBQztpQkFBTSxDQUFDO2dCQUNOLE1BQU0sRUFBRSxPQUFPLEVBQUUsUUFBUSxFQUFFLEdBQUcsTUFBTSxNQUFNLENBQUMsZ0JBQWdCLENBQUMsQ0FBQztnQkFDN0QsRUFBRSxHQUFHLElBQUksUUFBUSxDQUFDLElBQUksQ0FBQyxRQUFRLEVBQUUsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO2dCQUM1QyxFQUFFLENBQUMsTUFBTSxDQUFDLG9CQUFvQixDQUFDLENBQUM7WUFDbEMsQ0FBQztZQUNELElBQUksQ0FBQyxPQUFPLEdBQUcsSUFBSSxhQUFhLENBQUMsRUFBRSxFQUFFLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUNuRCxDQUFDO1FBQ0QsT0FBTyxJQUFJLENBQUMsT0FBTyxDQUFDO0lBQ3RCLENBQUM7SUFFRCxLQUFLLENBQUMsR0FBRztRQUNQLE1BQU0sSUFBSSxDQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDOUIsT0FBTyxJQUFJLENBQUMsT0FBTyxDQUFDO0lBQ3RCLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgT3B0aW9ucyB9IGZyb20gJ2JldHRlci1zcWxpdGUzJztcbmltcG9ydCB7IEFic3RyYWN0UXVlcmllclBvb2wgfSBmcm9tICcuLi9xdWVyaWVyL2luZGV4LmpzJztcbmltcG9ydCB0eXBlIHsgRXh0cmFPcHRpb25zIH0gZnJvbSAnLi4vdHlwZS9pbmRleC5qcyc7XG5pbXBvcnQgeyBTcWxpdGVRdWVyaWVyIH0gZnJvbSAnLi9zcWxpdGVRdWVyaWVyLmpzJztcblxuZXhwb3J0IGNsYXNzIFNxbGl0ZTNRdWVyaWVyUG9vbCBleHRlbmRzIEFic3RyYWN0UXVlcmllclBvb2w8U3FsaXRlUXVlcmllcj4ge1xuICBwcml2YXRlIHF1ZXJpZXI6IFNxbGl0ZVF1ZXJpZXI7XG5cbiAgY29uc3RydWN0b3IoXG4gICAgcmVhZG9ubHkgZmlsZW5hbWU/OiBzdHJpbmcgfCBCdWZmZXIsXG4gICAgcmVhZG9ubHkgb3B0cz86IE9wdGlvbnMsXG4gICAgZXh0cmE/OiBFeHRyYU9wdGlvbnMsXG4gICkge1xuICAgIHN1cGVyKCdzcWxpdGUnLCBleHRyYSk7XG4gIH1cblxuICBhc3luYyBnZXRRdWVyaWVyKCkge1xuICAgIGlmICghdGhpcy5xdWVyaWVyKSB7XG4gICAgICBsZXQgZGI6IGFueTtcbiAgICAgIGlmICh0eXBlb2YgQnVuICE9PSAndW5kZWZpbmVkJykge1xuICAgICAgICBjb25zdCB7IERhdGFiYXNlIH0gPSBhd2FpdCBpbXBvcnQoJ2J1bjpzcWxpdGUnKTtcbiAgICAgICAgZGIgPSBuZXcgRGF0YWJhc2UodGhpcy5maWxlbmFtZSBhcyBzdHJpbmcsIHRoaXMub3B0cyBhcyBhbnkpO1xuICAgICAgICBkYi5ydW4oJ1BSQUdNQSBqb3VybmFsX21vZGUgPSBXQUwnKTtcbiAgICAgIH0gZWxzZSB7XG4gICAgICAgIGNvbnN0IHsgZGVmYXVsdDogRGF0YWJhc2UgfSA9IGF3YWl0IGltcG9ydCgnYmV0dGVyLXNxbGl0ZTMnKTtcbiAgICAgICAgZGIgPSBuZXcgRGF0YWJhc2UodGhpcy5maWxlbmFtZSwgdGhpcy5vcHRzKTtcbiAgICAgICAgZGIucHJhZ21hKCdqb3VybmFsX21vZGUgPSBXQUwnKTtcbiAgICAgIH1cbiAgICAgIHRoaXMucXVlcmllciA9IG5ldyBTcWxpdGVRdWVyaWVyKGRiLCB0aGlzLmV4dHJhKTtcbiAgICB9XG4gICAgcmV0dXJuIHRoaXMucXVlcmllcjtcbiAgfVxuXG4gIGFzeW5jIGVuZCgpIHtcbiAgICBhd2FpdCB0aGlzLnF1ZXJpZXIuZGIuY2xvc2UoKTtcbiAgICBkZWxldGUgdGhpcy5xdWVyaWVyO1xuICB9XG59XG4iXX0=

package/dist/sqlite/sqliteQuerierPool.test.d.ts

@@ -0,0 +1,5 @@
+import { AbstractQuerierPoolIt } from '../querier/abstractQuerierPool-test.js';
+import type { SqliteQuerier } from './sqliteQuerier.js';
+export declare class Sqlite3QuerierPoolIt extends AbstractQuerierPoolIt<SqliteQuerier> {
+    constructor();
+}

package/dist/sqlite/sqliteQuerierPool.test.js

@@ -0,0 +1,10 @@
+import { AbstractQuerierPoolIt } from '../querier/abstractQuerierPool-test.js';
+import { createSpec } from '../test/index.js';
+import { Sqlite3QuerierPool } from './sqliteQuerierPool.js';
+export class Sqlite3QuerierPoolIt extends AbstractQuerierPoolIt {
+    constructor() {
+        super(new Sqlite3QuerierPool(':memory:'));
+    }
+}
+createSpec(new Sqlite3QuerierPoolIt());
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3FsaXRlUXVlcmllclBvb2wudGVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zcWxpdGUvc3FsaXRlUXVlcmllclBvb2wudGVzdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSx3Q0FBd0MsQ0FBQztBQUMvRSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFOUMsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFFNUQsTUFBTSxPQUFPLG9CQUFxQixTQUFRLHFCQUFvQztJQUM1RTtRQUNFLEtBQUssQ0FBQyxJQUFJLGtCQUFrQixDQUFDLFVBQVUsQ0FBQyxDQUFDLENBQUM7SUFDNUMsQ0FBQztDQUNGO0FBRUQsVUFBVSxDQUFDLElBQUksb0JBQW9CLEVBQUUsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQWJzdHJhY3RRdWVyaWVyUG9vbEl0IH0gZnJvbSAnLi4vcXVlcmllci9hYnN0cmFjdFF1ZXJpZXJQb29sLXRlc3QuanMnO1xuaW1wb3J0IHsgY3JlYXRlU3BlYyB9IGZyb20gJy4uL3Rlc3QvaW5kZXguanMnO1xuaW1wb3J0IHR5cGUgeyBTcWxpdGVRdWVyaWVyIH0gZnJvbSAnLi9zcWxpdGVRdWVyaWVyLmpzJztcbmltcG9ydCB7IFNxbGl0ZTNRdWVyaWVyUG9vbCB9IGZyb20gJy4vc3FsaXRlUXVlcmllclBvb2wuanMnO1xuXG5leHBvcnQgY2xhc3MgU3FsaXRlM1F1ZXJpZXJQb29sSXQgZXh0ZW5kcyBBYnN0cmFjdFF1ZXJpZXJQb29sSXQ8U3FsaXRlUXVlcmllcj4ge1xuICBjb25zdHJ1Y3RvcigpIHtcbiAgICBzdXBlcihuZXcgU3FsaXRlM1F1ZXJpZXJQb29sKCc6bWVtb3J5OicpKTtcbiAgfVxufVxuXG5jcmVhdGVTcGVjKG5ldyBTcWxpdGUzUXVlcmllclBvb2xJdCgpKTtcbiJdfQ==