@jantstack/adonis-authz 1.1.0 → 2.4.0-alpha.1

package/build/src/drivers/database_driver.d.ts

@@ -1,5 +1,10 @@
-import type { AuthorizationDriver, GrantOptions, ScopeRef, ScopeType, SubjectRef } from '../types.js';
-import type { ScopeAncestorsResolver } from '../types.js';
+import db from '@adonisjs/lucid/services/db';
+import type { AuthorizationDriver, CatalogRoleRef, DenyRef, GrantOptions, GrantOutcome, NormalizedRoleQuery, ReconcileOptions, ReconcileReport, ReconcileSource, RoleQuery, ScopeRef, ScopeType, SubjectRef } from '../types.js';
+import type { ScopeChainResolver } from '../types.js';
+import { CatalogCache } from '../catalog/catalog_cache.js';
+import type { CatalogRevalidate, CatalogRole, CatalogView } from '../catalog/catalog_cache.js';
+import type { Clock } from '../clock.js';
+export type QueryBuilder = ReturnType<typeof db.from>;
 /**
  * UUID centinela para el scope 'app' en las columnas scope_uuid (NOT NULL):
  * permite que el unique de assignments/denies cubra también el nivel app
@@ -7,6 +12,129 @@ import type { ScopeAncestorsResolver } from '../types.js';
  * de ESTE driver — la API pública sigue usando uuid null para app.
  */
 export declare const APP_SCOPE_DB_UUID = "00000000-0000-0000-0000-000000000000";
+/**
+ * La vuelta de `toDbScopeUuid`: el centinela de la raíz vuelve a ser `null`.
+ * **Exportada desde 3b-3b**: `authz:reconcile --to=openfga` lee estas mismas
+ * columnas y hacía `row.scope_uuid ?? null`, que con la columna NOT NULL
+ * nunca es null — un grant o un deny en la RAÍZ reventaban la migración con
+ * un 422 a mitad de pasada (`el scope 'app' no admite uuid`). Lo cazó el
+ * contrato de migración, cuya siembra fija sí concede en `app`.
+ */
+export declare function fromDbScopeUuid(uuid: string): string | null;
+/**
+ * El rol `(slug, scopeType)` que existe en el scope cuya cadena empieza por
+ * `chainKeys`, o 422: `E_AUTHZ_ROLE_NOT_VISIBLE` si hay roles con ese nombre
+ * pero todos son locales a otro contenedor; `E_AUTHZ_UNKNOWN_ROLE` si no hay
+ * ninguno. Compartido por ambos drivers (3B · B2).
+ */
+export declare function visibleRoleOrFail(catalog: CatalogView, slug: string, scope: ScopeRef, chainKeys: readonly string[]): CatalogRole;
+/**
+ * EL rol al que apunta un `RoleQuery` en un scope concreto (3D · M1), para
+ * las rutas que direccionan un rol exacto (`grant`, `listSubjects`):
+ *
+ *  - `{ uuid }`: resolución EXACTA, sin ambigüedad posible. Fuera del
+ *    catálogo ⇒ 422 `E_AUTHZ_UNKNOWN_ROLE`; declarado para otro nivel o con
+ *    el owner fuera de la cadena ⇒ 422 `E_AUTHZ_ROLE_NOT_VISIBLE` (no existe
+ *    AQUÍ, que es lo mismo que decía la ruta por slug).
+ *  - slug (con nivel opcional): `visibleRoleOrFail`, que ahora falla cerrado
+ *    si hay más de un homónimo visible (422 `E_AUTHZ_AMBIGUOUS_ROLE`).
+ *
+ * Compartido por ambos drivers.
+ */
+export declare function resolveRoleQuery(catalog: CatalogView, role: RoleQuery, scope: ScopeRef, chainKeys: readonly string[]): CatalogRole;
+/**
+ * EL rol al que apunta un `RoleQuery` en un scope, para el camino de LECTURA
+ * (`listSubjects`): `null` si el catálogo no declara ninguno que exista ahí
+ * (invariante 5: desconocido no lanza). La AMBIGÜEDAD sí lanza (3D · M1):
+ * elegir uno de dos homónimos era enumerar los holders del otro tenant.
+ */
+export declare function visibleRoleFor(catalog: CatalogView, query: NormalizedRoleQuery, scope: ScopeRef, chainKeys: readonly string[]): CatalogRole | null;
+/**
+ * Los roles a los que un `RoleQuery` puede referirse en un scope, para
+ * `revoke` (3D · M1): por uuid, ESE rol (422 si el catálogo no lo declara);
+ * por slug, TODOS los homónimos `(slug, nivel)` — quitar nunca concede y el
+ * scope puede no existir ya para el árbol (D8), así que no se resuelve la
+ * ambigüedad: se quitan todos. 422 `E_AUTHZ_UNKNOWN_ROLE` si no hay ninguno.
+ */
+export declare function rolesToRevoke(catalog: CatalogView, role: RoleQuery, scope: ScopeRef): CatalogRole[];
+/**
+ * Los niveles de la cadena donde una asignación de ESE rol contaría, para
+ * `hasRole` (3D · M1): los scopes del tipo del rol desde los que el rol es
+ * visible por owner. `null` = el catálogo no declara nada que responda (la
+ * membresía es `false`, nunca un throw: invariante 5).
+ */
+export declare function hasRoleTargets(catalog: CatalogView, role: RoleQuery, chain: ScopeRef[]): Array<{
+    scope: ScopeRef;
+    roleUuid: string;
+}>;
+/**
+ * Control de COMPOSICIÓN en la escritura (3B · B5, defensa en profundidad):
+ * un rol de nivel L que lleve un permiso cuyo `assignableAt` no incluye L no
+ * se asigna (422 `E_AUTHZ_ROLE_NOT_ASSIGNABLE_AT`). El sync y
+ * `defineScopedRole` ya lo rechazan al componer; aquí se cierra el vínculo
+ * escrito a mano. `authorize` NUNCA lo mira: lo ya asignado sigue
+ * concediendo (invariante 1).
+ */
+export declare function assertRoleAssignableAt(catalog: CatalogView, role: CatalogRole): void;
+/**
+ * EL rol de un uuid, si EXISTE en un scope de nivel `scopeType` cuya cadena
+ * tiene esas claves: declarado para ese nivel (D5/L0.6) y global o con el
+ * owner en la cadena desde ahí (3B · B2). `null` si no. Es la regla de
+ * visibilidad por uuid, en UN sitio (3D · N5): la usan `listRoles`,
+ * `rolesInChain`, `listRoleScopes`/`listScopes` (`visibleAt`) en `database`
+ * y `declaredRole` en `openfga`.
+ */
+export declare function declaredRoleAt(catalog: CatalogView, roleUuid: string, scopeType: ScopeType, chainKeys: readonly string[]): CatalogRole | null;
+/**
+ * Filtro (scope_type, scope_uuid) ∈ scopes (centinela para el nivel app).
+ *
+ * Con `scopes` VACÍO no hay filtro que construir, y "sin filtro" en SQL es
+ * "todas las filas": la consulta de denies sobre-bloquearía (cerrado) pero la
+ * de asignaciones concedería en CUALQUIER scope (abierto) — L0.1. Hoy ningún
+ * call-site pasa un conjunto vacío (la cadena siempre contiene el scope), pero
+ * `descendantsOf`/`authorizedScopes` (Fase 2) lo harán alcanzable:
+ *  - lectura ⇒ `null`: nada puede coincidir, el llamante responde vacío/false
+ *    SIN ejecutar la consulta;
+ *  - escritura ⇒ 500: escribir "en ningún scope" es un bug de programación.
+ * Exportada (no método privado) para poder fijarlo con un test.
+ */
+export declare function whereScopeIn(query: QueryBuilder, column: string, scopes: ScopeRef[], intent: 'write'): QueryBuilder;
+export declare function whereScopeIn(query: QueryBuilder, column: string, scopes: ScopeRef[], intent: 'read'): QueryBuilder | null;
+export interface DatabaseDriverOptions {
+    /** Jerarquía del consumidor: la cadena canónica de cada scope (ver `ScopeChainResolver`). */
+    resolveChain?: ScopeChainResolver;
+    /**
+     * Deadline de cada consulta SQL en ms (default 5000). Vencido ⇒ 503
+     * `E_AUTHZ_BACKEND_TIMEOUT`. Sin deadline, una base saturada convertía cada
+     * request autorizada en un socket retenido para siempre (L0.13).
+     */
+    timeoutMs?: number;
+    /**
+     * Memo del catálogo compartido con otro driver del mismo proceso (2A). Si
+     * se omite, el driver construye el suyo. Se revalida contra la versión
+     * compartida de la base (`authz_catalog_version`) según `catalogRevalidate`.
+     */
+    catalog?: CatalogCache;
+    /**
+     * Cuándo contrastar el memo con la versión compartida (2D · F1): `'always'`
+     * (default; un SELECT por clave primaria por pregunta) o `{ everyMs }`
+     * (opt-in: ventana acotada en la que un sync de OTRO proceso aún no se ve).
+     * Solo aplica al memo que construye este driver.
+     */
+    catalogRevalidate?: CatalogRevalidate;
+    /**
+     * Reloj de pared con el que el driver DECIDE la caducidad (2.5 · J1):
+     * `expires_at > now()` en cada lectura y los tres estados del re-grant.
+     * Default `() => new Date()`. Inyectable para fijar el instante en tests;
+     * en producción lo normal es no tocarlo (o pasar `clock` en el config del
+     * manager, que lo aplica con `withClock`). Los sellos de auditoría
+     * (`created_at`) NO lo usan (2.5-B · K5): son «cuándo se escribió», no
+     * una decisión, y con `TIMESTAMP` de MySQL un reloj inyectado en 2040
+     * hacía imposible escribir.
+     */
+    now?: Clock;
+}
+export declare const DEFAULT_TIMEOUT_MS = 5000;
 /**
  * Driver `database`: motor de autorización propio sobre las tablas `authz_*`.
  * Default autosuficiente del chasis (cero piezas extra en el appliance).
@@ -16,33 +144,214 @@ export declare const APP_SCOPE_DB_UUID = "00000000-0000-0000-0000-000000000000";
  * permiso vía su rol. La cadena es `[scope, ...ancestros]` — herencia solo
  * hacia abajo. Solo SQL estándar vía query builder (regla M6: nada
  * específico de un motor).
+ *
+ * Toda consulta pasa por `sql()`: un fallo del cliente SQL (conexión, tabla,
+ * deadline) sale como `AuthorizationBackendError` 503, nunca como el error
+ * crudo de knex (L0.11).
  */
 export declare class DatabaseAuthorizationDriver implements AuthorizationDriver {
+    /**
+     * Lo que este driver declara (3b-2e · E2). El árbol es del consumidor
+     * (`resolveChain`), así que no hay hechos de jerarquía ni deriva que
+     * mitigar; `authorize` son varias consultas SQL; la membresía la resuelve
+     * el propio SQL contra la cadena que le pasan; los `list*` no enumeran
+     * herencia (invariante 7); y `purgeRole` está implementado en una
+     * transacción.
+     */
+    readonly capabilities: Readonly<{
+        hierarchyFacts: false;
+        singleCheckAuthorize: false;
+        roleInheritanceNative: false;
+        listObjectsInherited: false;
+        purgeRole: true;
+        countRoleAssignments: true;
+        canonicalScopeReads: true;
+        enumerateFacts: false;
+    }>;
     /**
      * Resolutor de jerarquía inyectado por el consumidor (el chasis pasa el
      * suyo, que conoce organizations/units, en `config/authorization.ts`).
-     * Default puro sin dominio: todo cuelga directamente de `app`.
+     * Sin él, el driver solo conoce la raíz (L0.3: ya no hay default plano).
+     */
+    private chainResolver;
+    private timeoutMs;
+    /** Reloj de pared del driver (J1): el ÚNICO `now` de todas sus DECISIONES temporales (no de los sellos, K5). */
+    private now;
+    /**
+     * Cómo viaja `expires_at` con este motor (2.5-B · K2): cadena UTC explícita
+     * en MySQL (sin depender de `timezone`/`TZ`), identidad en el resto. Se
+     * decide por dialecto en el primer uso (la conexión puede no estar lista al
+     * construir el driver).
+     */
+    private expiryCodec;
+    /**
+     * Memo del catálogo (2A): `findPermission`/`findRole` leen de aquí; los
+     * hechos (asignaciones, denies y el join con los vínculos) siguen en SQL en
+     * cada pregunta. Se revalida contra `authz_catalog_version` (2D · F1);
+     * `catalog.invalidate()` fuerza la recarga de ESTE memo.
+     */
+    readonly catalog: CatalogCache;
+    constructor(options?: DatabaseDriverOptions);
+    /**
+     * Vista de este driver con OTRO resolutor de la cadena y el mismo estado
+     * (conexión, memo del catálogo, deadline). Es lo que usa
+     * `AuthorizationManager.forRequest()` para leer con un resolutor memoizado
+     * sin tocar el driver compartido: el objeto devuelto hereda del original
+     * por prototipo y solo sobrescribe el resolutor.
+     */
+    withChainResolver(resolveChain: ScopeChainResolver): AuthorizationDriver;
+    /**
+     * Vista de este driver con OTRO reloj de pared (2.5 · J1) y el mismo estado
+     * (conexión, memo, deadline, resolutor). Es lo que aplica el manager con
+     * `config.clock` y lo que el juez usa para fijar el instante. Misma
+     * técnica que `withChainResolver`: herencia por prototipo, un campo.
+     */
+    withClock(now: Clock): AuthorizationDriver;
+    /**
+     * `[scope canónico, ...ancestros]`, o `null` si el scope no existe
+     * (lecturas: denegar). `chain[0]` —la fila del consumidor, no lo que
+     * escribió el llamante— es la identidad con la que se leen y escriben los
+     * hechos de ese scope (2.5-B · K1): un alias del uuid que el árbol funde
+     * con la fila real (tipo `uuid` de PG, collation `*_ci`) llega aquí ya
+     * canónico y el deny escrito canónico casa.
      */
-    private resolveAncestors;
-    constructor(options?: {
-        resolveAncestors?: ScopeAncestorsResolver;
-    });
     private chain;
-    /** Filtro (scope_type, scope_uuid) ∈ scopes (centinela para el nivel app). */
-    private whereScopeIn;
-    /** Asignación vigente: sin expiración o con expiración futura. */
+    /** La cadena o 422: una escritura no puede ir a un scope que nadie reconoce. */
+    private knownScope;
+    /** El scope canónico para `purgeScope` (ver `canonicalScope`). */
+    private canonicalOrSelf;
+    /** Los destinos de un delete de hechos (`revoke`/`removeDeny`): canónico, o el fan-out de alias (3b-8 · A4). */
+    private canonicalTargets;
+    /**
+     * Ejecuta una consulta clasificando su fallo (503 con código propio). `fn`
+     * devuelve el BUILDER sin ejecutar: el guard le fija el deadline y luego lo
+     * ejecuta. Por eso no se usa `.first()` de Lucid (ejecuta al instante, sin
+     * dejar poner el timeout): `first()` de abajo hace `limit(1)` y toma la fila.
+     */
+    private sql;
+    private first;
+    private get expiry();
+    /** Asignación vigente: sin expiración o con expiración futura (estricta: la que vence AHORA ya no cuenta). */
     private whereActive;
     private findPermission;
-    private findRoleOrFail;
+    /**
+     * Filtro «asignación VISIBLE en algún nivel de la cadena» (3B · B2), en
+     * SQL, sobre `authz_assignments as a` unida a `authz_roles as r`: por cada
+     * nivel `i`, el scope exacto Y el rol declarado para ese nivel Y (global O
+     * owner en `chain.slice(i)`). Sustituye a `whereScopeIn(chain)` en la
+     * consulta de `authorize`: mismo número de consultas, ahora con el owner
+     * decidido en la base (`owner_scope_key IN (...) OR 'global'`). La cadena
+     * viene validada (nunca vacía); L0.1 se conserva por si acaso.
+     */
+    private whereVisibleAssignmentIn;
     authorize(subject: SubjectRef, permission: string, scope: ScopeRef): Promise<boolean>;
-    grant(subject: SubjectRef, role: string, scope: ScopeRef, options?: GrantOptions): Promise<void>;
-    revoke(subject: SubjectRef, role: string, scope: ScopeRef): Promise<void>;
-    hasRole(subject: SubjectRef, role: string, scope: ScopeRef): Promise<boolean>;
+    grant(subject: SubjectRef, role: RoleQuery, scope: ScopeRef, options?: GrantOptions): Promise<GrantOutcome>;
+    /**
+     * Re-grant sobre una asignación existente (L0.4): omitido preserva una
+     * caducidad vigente (o revive una expirada sin caducidad), `null` la quita,
+     * `Date` la fija. Solo se escribe si la caducidad cambia de verdad; si el
+     * UPDATE no toca ninguna fila (otro proceso la borró entre la lectura y la
+     * escritura, K4) devuelve `null`: no hay «existed: true» sobre nada.
+     */
+    private refreshAssignment;
+    revoke(subject: SubjectRef, role: RoleQuery, scope: ScopeRef): Promise<void>;
+    hasRole(subject: SubjectRef, role: RoleQuery, scope: ScopeRef): Promise<boolean>;
     deny(subject: SubjectRef, permission: string, scope: ScopeRef): Promise<void>;
     removeDeny(subject: SubjectRef, permission: string, scope: ScopeRef): Promise<void>;
-    listSubjects(role: string, scope: ScopeRef): Promise<SubjectRef[]>;
+    listSubjects(role: RoleQuery, scope: ScopeRef): Promise<SubjectRef[]>;
     listRoles(subject: SubjectRef, scope: ScopeRef): Promise<string[]>;
+    /**
+     * Roles directos vigentes del holder en cada scope de la cadena (2D · G5):
+     * UNA consulta con `whereScopeIn(chain)` en vez de un `listRoles` por
+     * nivel. El filtro por catálogo (D5) es el memo, por uuid (3A · A2): el
+     * rol tiene que existir y estar declarado para el nivel de la asignación.
+     * La cadena viene ya resuelta por el manager.
+     */
+    rolesInChain(subject: SubjectRef, chain: ScopeRef[]): Promise<Array<{
+        scope: ScopeRef;
+        role: CatalogRoleRef;
+    }>>;
     listRoleScopes(subject: SubjectRef, scopeType: ScopeType): Promise<ScopeRef[]>;
+    /** ¿El rol (por uuid) existe en el scope cuya cadena tiene esas claves? (3B · B2, `declaredRoleAt`) */
+    private visibleAt;
     listScopes(subject: SubjectRef, permission: string): Promise<ScopeRef[]>;
+    /**
+     * Denies directos del holder (2.1, B5): del scope exacto o todos. Solo los
+     * de permisos que el catálogo declara (memo); los de scopes que el árbol
+     * no conoce no se listan (D8), como en `listRoleScopes`.
+     */
+    listDenies(subject: SubjectRef, scope?: ScopeRef): Promise<DenyRef[]>;
+    /**
+     * Borra asignaciones y denies del scope exacto, en una transacción. Si el
+     * árbol aún lo conoce se purga su identidad canónica (K1); si ya no (el
+     * consumidor borró la fila antes de avisar) se purga tal cual llegó. Con
+     * `DELETE` en SQL la propia sentencia demuestra el cero: no hay residuo
+     * posible.
+     */
+    purgeScope(purged: ScopeRef): Promise<void>;
+    /**
+     * Purga un rol con sus hechos (3B · B4): sus asignaciones en TODOS los
+     * scopes, sus vínculos y la fila, en UNA transacción que sube la versión
+     * compartida del catálogo como última sentencia (`withAuthzCatalogWrite`):
+     * los demás procesos dejan de verlo en su siguiente pregunta. Se lee la
+     * fila en fresco (no el memo): purgar es escribir. Con `DELETE` la propia
+     * sentencia demuestra el cero. Global o local: la barrera «los globales son
+     * inmutables» es del manager (`deleteScopedRole`); por aquí (plataforma,
+     * `manager.driver()`) se purga lo que se pida.
+     */
+    purgeRole(roleUuid: string): Promise<void>;
+    /**
+     * Cuántos hechos VIGENTES tiene cada rol, en todos los scopes (3b-2j). Es
+     * lo que `pruneOrphanRoles` necesita para decir si un huérfano todavía
+     * concede, y es una pregunta del PUERTO porque los hechos son del driver:
+     * aquí son filas de `authz_assignments`, en `openfga` son tuplas del store.
+     *
+     * Una consulta agrupada para todos los uuids (no una por rol) y la misma
+     * caducidad ESTRICTA que el resto del driver, con SU reloj (`whereActive`,
+     * J1): la asignación que vence ahora ya no cuenta, como no cuenta en
+     * `authorize`. Un rol sin hechos —o que no está en la tabla— es `0`.
+     */
+    countRoleAssignments(roleUuids: string[]): Promise<number[]>;
+    /**
+     * **Rehace `authz_assignments`/`authz_denies` desde los hechos de OTRO
+     * driver** — la vuelta de la migración, y con ella la simetría que el dueño
+     * compró: «todo en un driver o todo en otro».
+     *
+     * Qué se migra y qué NO, y por qué:
+     *  - **los HECHOS, sí**: es lo único que vive en el otro driver. Llegan por
+     *    `source.facts` —el puerto `enumerateFacts`, paginado— y no por SQL:
+     *    aquí el origen es un store, no una tabla de este paquete.
+     *  - **el ÁRBOL, no**. En esta dirección el árbol NO se migra: el driver
+     *    `database` lo lee de las tablas del CONSUMIDOR en cada pregunta
+     *    (`resolveChain`), que son su fuente de verdad. Copiarlo a algún sitio
+     *    sería inventarse una segunda copia y con ella una deriva que hoy no
+     *    existe. Se usa, eso sí, para decidir qué hecho es migrable
+     *    (`unknown-scope`) y bajo qué identidad CANÓNICA se escribe
+     *    (invariante 17).
+     *  - **el CATÁLOGO, tampoco**: es propiedad local SIEMPRE (regla de higiene
+     *    del paquete), ya está en `authz_*` y ningún driver es su fuente. Aquí
+     *    solo se usa para traducir: un `roleUuid` que el catálogo no declara y
+     *    un permiso que no existe no son hechos migrables.
+     *
+     * Por eso `phases.root`, `phases.catalog` y `phases.tree` son CERO en esta
+     * dirección, y todo el movimiento está en `phases.facts`. Es una respuesta,
+     * no un hueco: los ceros dicen «aquí no hay nada derivado que rehacer».
+     *
+     * El resto del contrato es el mismo que en la ida (3b-3a): idempotente (la
+     * segunda pasada escribe cero), `dryRun` es el VERIFICADOR y es read-only
+     * por contrato —**un `--fix` está prohibido** (cruce 4 · S18) y no se
+     * implementa ni se deja preparado—, nunca silenciosa (`skipped{motivo}` +
+     * `details`), los hechos que sobran solo se borran con `prune`, y el
+     * seguro del origen ciego (`E_AUTHZ_MASS_RECONCILE_REFUSED`) se aplica
+     * igual: un origen que devuelve CERO hechos y un `--prune` detrás vacían
+     * la base, y eso es casi siempre apuntar al store equivocado.
+     */
+    reconcile(source: ReconcileSource, options?: ReconcileOptions): Promise<ReconcileReport>;
+    /**
+     * Pasea una tabla `authz_*` por lotes con cursor sobre `uuid` (PK: orden
+     * total y estable). Lo mismo que hace `openfga.reconcile` con el origen,
+     * por el mismo motivo: una base grande no entra entera de golpe.
+     */
+    private eachReconcileRow;
 }
 //# sourceMappingURL=database_driver.d.ts.map

package/build/src/drivers/database_driver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"database_driver.d.ts","sourceRoot":"","sources":["../../../src/drivers/database_driver.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,mBAAmB,EACnB,YAAY,EACZ,QAAQ,EACR,SAAS,EACT,UAAU,EACX,MAAM,aAAa,CAAA;AAEpB,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAA;AAIzD;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,yCAAyC,CAAA;AAUvE;;;;;;;;;GASG;AACH,qBAAa,2BAA4B,YAAW,mBAAmB;IACrE;;;;OAIG;IACH,OAAO,CAAC,gBAAgB,CAAwB;gBAEpC,OAAO,GAAE;QAAE,gBAAgB,CAAC,EAAE,sBAAsB,CAAA;KAAO;YAKzD,KAAK;IAInB,8EAA8E;IAC9E,OAAO,CAAC,YAAY;IAUpB,kEAAkE;IAClE,OAAO,CAAC,WAAW;YAML,cAAc;YAId,cAAc;IAetB,SAAS,CAAC,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC;IAkCrF,KAAK,CACT,OAAO,EAAE,UAAU,EACnB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,QAAQ,EACf,OAAO,GAAE,YAAiB,GACzB,OAAO,CAAC,IAAI,CAAC;IAqDV,MAAM,CAAC,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAoBzE,OAAO,CAAC,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC;IAkB7E,IAAI,CAAC,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IA2C7E,UAAU,CAAC,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAenF,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;IAiBlE,SAAS,CAAC,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAgBlE,cAAc,CAAC,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;IAY9E,UAAU,CAAC,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;CAkC/E"}
+{"version":3,"file":"database_driver.d.ts","sourceRoot":"","sources":["../../../src/drivers/database_driver.ts"],"names":[],"mappings":"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"}