@aooth/arbac-moost 0.1.71 → 0.1.72

package/dist/{user.provider-C5BrFNxg.d.mts → user.provider-NMSzynGK.d.mts}

@@ -1,8 +1,53 @@
-import { TClassConstructor } from "moost";
-import { ControlGate, TProjection, TProjectionChildren, TScopeFilter } from "@aooth/arbac";
-import { TMetaResponse } from "@atscript/db";
-import { AsDbController } from "@atscript/moost-db";
-import { NavPropsOf, OwnPropsOf, TAtscriptAnnotatedType } from "@atscript/typescript/utils";
+import { Mate, TClassConstructor, TMateParamMeta, TMoostMetadata } from "moost";
+import { ControlGate, TProjection, TProjectionChildren, TScopeFieldRules, TScopeFilter } from "@aooth/arbac";
+import { TDbRemoveGuardContext, TDbWriteAction, TDbWriteCheckContext, TDbWriteGuardContext, TMetaResponse } from "@atscript/db";
+import { AsDbController, TDbControlsType, TDbRequestContext } from "@atscript/moost-db";
+import { NavPropsOf, OwnPropsOf, TAtscriptAnnotatedType, TAtscriptDataType } from "@atscript/typescript/utils";
+//#region src/arbac.mate.d.ts
+/**
+ * ARBAC metadata fields attached to classes and methods by ARBAC decorators.
+ *
+ * Augments the shared `TMoostMetadata` workspace via TypeScript declaration
+ * merging so other moost-aware tooling (and `getArbacMate()` readers) sees
+ * these fields with full type safety.
+ */
+interface TArbacMeta {
+  arbacResourceId?: string;
+  arbacActionId?: string;
+  arbacPublic?: boolean;
+}
+declare module "moost" {
+  interface TMoostMetadata extends TArbacMeta {}
+}
+type ArbacMate = Mate<TMoostMetadata & {
+  params: TMateParamMeta[];
+}, TMoostMetadata & {
+  params: TMateParamMeta[];
+}>;
+/**
+ * Returns the shared `Mate` instance typed with ARBAC metadata fields.
+ *
+ * All ARBAC decorators write through this typed wrapper so reads and writes
+ * stay type-checked against `TArbacMeta`.
+ */
+declare function getArbacMate(): ArbacMate;
+/**
+ * Marks a controller whose `prepareRequest` authorizes moost-db's delegated
+ * handlers (the ones `getDbEndpoint` tags, e.g. `GET meta/actions/:id`) with
+ * ARBAC: a method keyed by this symbol answers whether `method` is such a
+ * handler. The authorize interceptor then skips its own evaluation for that
+ * handler (the route has no grant of its own). `AsArbacDbController` /
+ * `AsArbacDbReadableController` carry it; a controller without it keeps the
+ * interceptor's normal (fail-closed) evaluation.
+ *
+ * @since 0.1.72
+ */
+declare const ARBAC_DELEGATED_AUTH: unique symbol;
+/** A controller carrying {@link ARBAC_DELEGATED_AUTH}. @since 0.1.72 */
+interface ArbacDelegatedAuth {
+  [ARBAC_DELEGATED_AUTH](method: string): boolean;
+}
+//#endregion
 //#region src/db/scope-types.d.ts
 /**
  * Unwrap a `NavPropsOf<T>[K]` value to its target model type:
@@ -54,6 +99,30 @@ type ControlsOf<T> = IsUnknown<T> extends true ? Record<string, ControlGate> : {
   [key: `$${string}`]: ControlGate | Array<string> | undefined;
 };
 //#endregion
+//#region src/db/write-fields.d.ts
+/**
+ * Test-friendly internal helper — exported for unit tests and helper
+ * composition; regular consumers should not call this directly.
+ *
+ * Apply the union of `allowedFields` whitelists (with `preserveFields`
+ * always preserved) and overlay each scope's `set` overrides. Returns a
+ * copy; the original `data` is not mutated.
+ *
+ * Path-aware: a top-level entry (`profile`) keeps the whole subtree; a
+ * dotted entry (`profile.name`) keeps only that branch of a nested object
+ * payload (`profile: { name, tenant }` → `profile: { name }`) — a non-object
+ * value under a partially whitelisted key is dropped, never kept whole. A
+ * dotted `set` key sets the nested path, merging into the payload's nested
+ * object.
+ *
+ * Patches (`isMergePatch` given): a nested object is written as a whole
+ * unless its path is a `@db.patch.strategy 'merge'` block, so a partially
+ * whitelisted REPLACE block is dropped (a partial block would clear the
+ * non-whitelisted leaves), and a dotted `set` under a replace block the patch
+ * does not carry is skipped (adding the block would clear its other leaves).
+ */
+declare function applyAllowedFieldsAndSet(data: unknown, scopes: ArbacDbScope[], preserveFields?: readonly string[], isMergePatch?: (objectPath: string) => boolean): unknown;
+//#endregion
 //#region src/db/as-arbac-db-controller.d.ts
 /**
  * Contract returned by an ARBAC role's scope predicate on a DB-backed resource.
@@ -71,9 +140,23 @@ type ControlsOf<T> = IsUnknown<T> extends true ? Record<string, ControlGate> : {
  *   }
  * }
  * ```
+ *
+ * The framework never reads a custom field — the app unions it with its own
+ * rule. Where scope lists are CONJOINED (credential attenuation), each custom
+ * field needs a conjunction rule registered once with
+ * `MoostArbac.registerScopeFields`; a custom field without one fails the
+ * evaluation (it is never silently dropped). Since 0.1.72.
  */
 interface ArbacDbScope<T = unknown> {
   filter?: TScopeFilter;
+  /**
+   * Post-write WITH CHECK filter: every row an insert / replace / update
+   * writes must match it (Postgres RLS semantics). Defaults to `filter`;
+   * `{}` disables the check. Conjoined (`$and`) like `filter` by
+   * `defineTableAccess` part scopes and credential attenuation; unioned
+   * across roles. Enforced by the ARBAC DB controllers from 0.1.72.
+   */
+  check?: TScopeFilter;
   projection?: ProjectionOf<T>;
   set?: Partial<Record<OwnFieldKey<T>, unknown>>;
   allowedFields?: Array<OwnFieldKey<T>>;
@@ -100,21 +183,47 @@ interface ArbacDbScope<T = unknown> {
    * `?$with=<name>`. Recursive — each sub-scope has the same shape and can
    * declare its own `with` for nested expansions (e.g. tasks → comments → task).
    *
-   * **Authority model**: the PARENT scope owns the policy for joined rows.
-   * arbac-moost does NOT re-evaluate ARBAC against the joined resource's own
-   * scopes — that would be a confusing indirection and a perf hit. Whatever
-   * the parent declares here is what surfaces from the expansion.
+   * **Which policy the joined rows obey** (0.1.72+):
+   * - Declared in any role → the union of those sub-scopes governs the
+   *   joined rows (silent roles contribute nothing).
+   * - Not declared → the caller's own `query` grant on the related table's
+   *   ARBAC resource (its filter, projection, controls and `with`); no grant
+   *   → `Unknown relation` (400), identical to a nonexistent relation.
    *
-   * **Union across roles**: when multiple roles allow the same parent table,
+   * **Union across roles**: when multiple roles declare the same relation,
    * their `with[name]` sub-scopes are unioned at every nested level using the
    * existing `unionProjections` / `mergeScopeFilters` / `unionControlsPolicy`
    * primitives (additive: broader access wins, same rules as the parent).
-   *
-   * **Silence wins**: if no role declares `with.<name>`, expansion is
-   * unrestricted (matches `controls.$with` whitelist semantics; the gate
-   * still applies if declared).
+   * The `controls.$with` gate still applies either way.
    */
   with?: WithOf<T>;
+  /**
+   * Nav relations (`TO` / `FROM` / `VIA` props) this scope may write THROUGH
+   * — nested inserts / updates of related rows in the parent's payload.
+   * Default deny: a write payload carrying a nav key not listed by any of
+   * the caller's write scopes is rejected with 403. Parent authority — the
+   * related rows are written under the PARENT scope, the related table's
+   * own ARBAC policy is not consulted. Enforced by the ARBAC DB controllers
+   * from 0.1.72.
+   */
+  nestedWrites?: Array<NavRelationKey<T>>;
+  /**
+   * FK target checks (opt-in): a write that SETS one of these foreign keys
+   * (insert / replace rows; update patches touching it) must reference rows
+   * the caller can READ under its own `query` grant on the target table's
+   * ARBAC resource — else 403 `Referenced row "<field>" is outside your
+   * scope`. `true` = every FK of the table; a list names FK fields or the TO
+   * relations they back. A target without a registered ARBAC DB controller or
+   * without a read grant → 403. Null / absent FKs are not checked.
+   *
+   * **Union across roles**: enforced for an FK only when EVERY allowing write
+   * scope enables it — write scopes grant additively, so a role without the
+   * flag grants unconstrained writes of that FK. Credential attenuation
+   * enforces what either side enforces.
+   *
+   * @since 0.1.72
+   */
+  checkRefs?: true | Array<OwnFieldKey<T> | NavRelationKey<T>>;
 }
 /**
  * Per-relation sub-scope map. For `T = unknown` falls back to the legacy
@@ -125,9 +234,43 @@ interface ArbacDbScope<T = unknown> {
  * because it must reference `ArbacDbScope` recursively.
  */
 type WithOf<T> = unknown extends T ? Record<string, ArbacDbScope> : { [K in NavRelationKey<T>]?: K extends keyof NavPropsOf<T> ? ArbacDbScope<NavTarget<NavPropsOf<T>[K]>> : ArbacDbScope; };
+/**
+ * ARBAC-enforcing CRUD controller over an atscript-db table.
+ *
+ * Every endpoint — `@DbAction` handlers included — resolves the caller's
+ * scopes first in `prepareRequest` (fail closed: no grant → 403, `@Public()`
+ * does not bypass it); every other hook reads them. Reads apply
+ * the scopes' row filter, projection, controls and `with` sub-scopes. Writes
+ * enforce, per request:
+ *
+ * - **nested writes** — a payload key naming a nav relation → 403 unless a
+ *   write scope lists it in `nestedWrites`;
+ * - **`allowedFields` / `set`** — path-aware whitelist (identifiers, the
+ *   version column and `$cas` always kept) and forced values;
+ * - **USING** — update / replace / delete target only rows matching the
+ *   scope `filter`, checked on the exact pre-image inside the write's
+ *   transaction (missing or out of scope → the same 404);
+ * - **`checkRefs`** (opt-in) — an FK the write sets must reference a row
+ *   the caller can read on the target table (else 403);
+ * - **WITH CHECK** — every written row must match the scope `check`
+ *   (default: `filter`; `{}` opts out) after the write, inside the
+ *   transaction (→ 403, rolled back). On adapters without real transactions
+ *   the check runs in memory before the write and fails closed on anything
+ *   it cannot decide.
+ */
 declare class AsArbacDbController<T extends TAtscriptAnnotatedType = TAtscriptAnnotatedType> extends AsDbController<T> {
-  protected transformFilter(filter: Record<string, unknown> | undefined): Promise<Record<string, unknown>>;
-  protected transformProjection(projection?: TProjection): TProjection | undefined | Promise<TProjection | undefined>;
+  /** Makes this controller the `$with` policy source for its table's ARBAC resource. */
+  protected readonly _arbacRelationTarget: true;
+  /**
+   * Resolve the request's ARBAC scopes before anything else consults them:
+   * reuse the ones the authorize interceptor cached, else evaluate the
+   * handler's resource/action now — a deny is a 403 (`arbacPublic` never
+   * bypasses a DB controller). On read endpoints the `$with` relation policy
+   * is resolved for the requested relations.
+   */
+  protected prepareRequest(ctx: TDbRequestContext): Promise<void>;
+  protected transformFilter(filter: Record<string, unknown> | undefined): Record<string, unknown>;
+  protected transformProjection(projection?: TProjection): TProjection | undefined;
   /**
    * Translate `@uniqu/url` parser failures into HTTP 400 instead of letting them
    * bubble as 500. The base `parseQueryString` calls `parseUrl()` directly with
@@ -152,32 +295,69 @@ declare class AsArbacDbController<T extends TAtscriptAnnotatedType = TAtscriptAn
    * controls of a request. Runs after the base validator (which checks the
    * controls DTO shape) and BEFORE the query/aggregation pipeline executes.
    *
-   * Reads the scopes the route-level authorize interceptor cached via
-   * `arbac.setScopes(...)` — validation runs before `transformFilter`, so
-   * this hook never re-evaluates ARBAC.
-   *
-   * On a violation we throw `HttpError(403)`. moost-db's `query` / `pages` /
-   * `getOne` handlers do NOT wrap `validateParsed` in try/catch, so the
-   * thrown error bubbles to moost which translates it to a 403 response.
+   * Reads the scopes `prepareRequest` resolved — unresolved scopes are a 403
+   * (never "unrestricted"). A violation throws `HttpError(403)`, which
+   * moost-db's read handlers let bubble.
    */
-  protected validateControls(controls: Record<string, unknown>, type: "query" | "pages" | "getOne"): string | undefined;
+  protected validateControls(controls: Record<string, unknown>, type: TDbControlsType): string | undefined;
   protected applyMetaOverlay(meta: TMetaResponse): Promise<TMetaResponse>;
   /**
-   * Scope-aware field visibility (BUG-3 twin of the `/meta` pruning above): a
+   * `GET /meta/form/:name` serves a form only when the caller may run at
+   * least one of the actions taking it as input (else the unknown-form 404).
+   */
+  protected authorizeForm(_name: string, actionNames: readonly string[]): Promise<boolean>;
+  /**
+   * The rows each `@DbAction` may run on: the caller's grant on that action
+   * (see `arbacActionRowScope`). Enforced by the action gate and reflected
+   * in `$actions` and `GET /meta/actions/:id`. Since 0.1.72.
+   */
+  protected actionRowScope(name: string): Promise<Record<string, unknown> | undefined>;
+  /**
+   * The row-level actions `$actions` and `GET /meta/actions/:id` may list:
+   * those the caller holds a grant on (the `/meta` overlay's rule, without
+   * building the overlay). Since 0.1.72.
+   */
+  protected allowedActions(names: readonly string[]): Promise<string[]>;
+  /**
+   * moost-db handlers that delegate their authorization to `prepareRequest`
+   * (`getDbEndpoint` — `GET /meta/actions/:id`): the authorize interceptor
+   * skips them; `prepareRequest` serves them iff the caller may run at least
+   * one row-level action (else 403). Since 0.1.72.
+   */
+  [ARBAC_DELEGATED_AUTH](method: string): boolean;
+  /**
+   * Scope-aware field visibility (the twin of the `/meta` pruning above): a
    * field outside the read-scope projection union answers `false`, which
    * moost-db's visibility hook turns into the same `Unknown field "x"` 400 a
    * nonexistent field gets at every gated query position — see the docs'
    * "Column-scope security floor". Identifiers stay visible. A `rel.x` path
-   * under a `with`-granted relation (`$with=rel(x>1)`, `$with=rel($sort=x)`,
-   * `$with=rel($select=x)`) is checked as `x` against the union of the
-   * `with.rel` sub-scopes, recursively; the related table's own PK /
-   * `preferredId` stay visible.
+   * (`$with=rel(x>1)`, `$with=rel($sort=x)`, `$with=rel($select=x)`) is
+   * checked as `x` against the relation's policy, recursively; the related
+   * table's own PK / `preferredId` stay visible. Unresolved scopes hide every
+   * field.
    */
   protected hasField(path: string): boolean;
-  protected onWrite(action: "insert" | "insertMany" | "replace" | "replaceMany" | "update" | "updateMany", data: unknown): Promise<unknown>;
-  protected onRemove(id: unknown): Promise<unknown>;
-  private assertInScope;
-  private identifierFields;
+  /**
+   * Untrusted-body stage: reject nested writes the scopes do not opt in
+   * (`nestedWrites`), then apply the `allowedFields` whitelist and `set`.
+   */
+  protected onWrite(action: TDbWriteAction, data: unknown): unknown;
+  /** `true` when a patch merges into the nested object at `path` (`@db.patch.strategy 'merge'`). */
+  private isMergeBlock;
+  /** In-transaction stage — USING, `checkRefs`, and WITH CHECK on non-transactional adapters. */
+  protected guardWrite(ctx: TDbWriteGuardContext<TAtscriptDataType<T>>): Promise<void>;
+  /** USING for deletes: the exact row the delete targets must match the scope filter (else 404). */
+  protected guardRemove(ctx: TDbRemoveGuardContext<TAtscriptDataType<T>>): Promise<void>;
+  /**
+   * WITH CHECK: after the write, inside its transaction, every written row
+   * must match the scopes' `check` (default `filter`) — else 403 and the
+   * write rolls back. Non-transactional adapters were checked in
+   * {@link guardWrite}.
+   */
+  protected checkWrite(ctx: TDbWriteCheckContext): Promise<void>;
+  /** `this.table` as the write guards see it (the generic `T` defeats structural matching). */
+  private get guardedTable();
+  private preservedWriteFields;
 }
 /**
  * Test-friendly internal helper — exported for unit tests and helper
@@ -219,15 +399,22 @@ declare function enforceControlsPolicy(policy: Record<string, ControlGate>, cont
  * gate, which throws if a non-whitelistable control receives a string[]).
  */
 declare function extractUsedControlValues(key: string, value: unknown, controls?: Record<string, unknown>): string[];
-/**
- * Test-friendly internal helper — exported for unit tests and helper
- * composition; regular consumers should not call this directly.
- *
- * Apply the union of `allowedFields` whitelists (with `preserveFields`
- * always preserved) and overlay each scope's `set` overrides. Returns a
- * shallow copy; original `data` is not mutated.
- */
-declare function applyAllowedFieldsAndSet(data: unknown, scopes: ArbacDbScope[], preserveFields?: readonly string[]): unknown;
+//#endregion
+//#region src/db/write-refs.d.ts
+/** A `@db.rel.FK` entry as atscript-db's readable exposes it. */
+interface RefForeignKey {
+  readonly fields: readonly string[];
+  readonly targetFields: readonly string[];
+  readonly targetTable?: string;
+  readonly alias?: string;
+  readonly targetTypeRef?: () => unknown;
+}
+/** The table surface `checkRefs` resolves names against (`AtscriptDbReadable` satisfies it). */
+interface RefTableSource {
+  readonly foreignKeys?: ReadonlyMap<string, RefForeignKey>;
+  /** The FK a TO relation is backed by (atscript-db's `readable.foreignKeyOf`). @since 0.1.72 */
+  foreignKeyOf?(relationName: string): RefForeignKey | undefined;
+}
 //#endregion
 //#region src/attenuation.d.ts
 /**
@@ -241,15 +428,23 @@ declare function applyAllowedFieldsAndSet(data: unknown, scopes: ArbacDbScope[],
  *
  * - `roles` — assume a SUBSET of the user's roles. `[]` = no roles (deny-all,
  *   fail-closed); an OMITTED key = keep all the user's roles (attrs-only
- *   narrowing); a role the user lacks is dropped by the intersection.
+ *   narrowing); a role the user lacks is dropped by the intersection (unless
+ *   `allowUnheldRoles`).
  * - `attrs` — extra/overriding inputs to scope predicates, keyed by the target
  *   user-attribute name, intended to narrow scopes. They are merged LOCALLY
  *   into the credential pass only and clipped by the scope conjunction, so they
  *   can never widen beyond the user.
+ * - `allowUnheldRoles` — "view as": evaluate the claimed `roles` as given,
+ *   including roles the user does not hold (unknown role ids still grant
+ *   nothing). The result is still conjoined with the user's full authority,
+ *   so it never widens beyond the user — it previews the claimed roles'
+ *   surface CLIPPED to the user's own. Opt-in: the app decides who may issue
+ *   such a credential (e.g. gate it behind a privilege). Since 0.1.72.
  */
 interface AoothArbacClaims {
   roles?: string[];
   attrs?: Record<string, unknown>;
+  allowUnheldRoles?: boolean;
 }
 /**
  * Conjoin the full-authority scopes (`userScopes`, the ceiling) and the
@@ -257,11 +452,12 @@ interface AoothArbacClaims {
  * `ArbacDbScope`. A row/field/control is admitted only if BOTH passes admit
  * it — the normative restrict-only clip that closes the attr-widen hole.
  *
- * Each side is first UNIONed with the existing additive helpers (today's
- * machinery), then the two RESULTS are CONJOINED with the dedicated combiners
- * ({@link conjoinScopeFilters} `$and`, {@link intersectProjections} field ∩,
- * {@link intersectControlsPolicy} deny-wins, `with` recursion) — never the
- * additive union helpers, which would silently widen.
+ * Each side is first UNIONed, then the two results are CONJOINED facet by
+ * facet with `conjoinScopes` from `@aooth/arbac` (`$and` filters and WITH
+ * CHECK filters, path-wise projection ∩, deny-wins controls, `allowedFields`
+ * / `nestedWrites` intersection, `set` combined with the USER winning a key
+ * conflict, recursive `with`) — never the additive union helpers, which
+ * would silently widen.
  *
  * Returned as a single-element list so every downstream scope-application
  * site (which UNIONs the cached scope list per facet) sees the identity of a
@@ -274,9 +470,26 @@ interface AoothArbacClaims {
  * closed). When NO field survives (`{a:1}` ∩ `{a:0}`, disjoint whitelists),
  * the composite keeps the user's projection and gets a match-nothing filter —
  * an empty field set must never read as the unrestricted `{}`. `with`
- * sub-scopes are conjoined without a schema.
+ * sub-scopes are conjoined without a schema. `checkRefs` enforces what either
+ * side enforces (resolved against `refTable`'s foreign keys when given — the
+ * evaluated table). A custom (declaration-merged) scope field is conjoined by
+ * its `fields` rule; without one this THROWS — never dropped (fail closed).
+ *
+ * The third argument is the options object, or (legacy form) `childrenOf`.
  */
-declare function conjoinArbacDbScopes(userScopes: ArbacDbScope[], credScopes: ArbacDbScope[], childrenOf?: TProjectionChildren): ArbacDbScope[];
+declare function conjoinArbacDbScopes(userScopes: ArbacDbScope[], credScopes: ArbacDbScope[], opts?: TProjectionChildren | ConjoinArbacDbScopesOptions): ArbacDbScope[];
+/** Options of {@link conjoinArbacDbScopes}. @since 0.1.72 */
+interface ConjoinArbacDbScopesOptions {
+  /** The evaluated table's schema lookup — subtracts a nested exclusion exactly. */
+  childrenOf?: TProjectionChildren;
+  /** The evaluated table — resolves `checkRefs` names to its foreign keys. */
+  refTable?: RefTableSource;
+  /**
+   * Custom scope field rules (`MoostArbac.registerScopeFields`); a custom
+   * field without one throws.
+   */
+  fields?: TScopeFieldRules<ArbacDbScope>;
+}
 //#endregion
 //#region src/user.provider.d.ts
 /**
@@ -334,4 +547,4 @@ declare abstract class ArbacUserProvider<TUserAttrs extends object = object> {
  */
 declare const ArbacUserProviderToken: TClassConstructor<ArbacUserProvider>;
 //#endregion
-export { ArbacDbScope as a, enforceControlsPolicy as c, NavRelationKey as d, NavTarget as f, conjoinArbacDbScopes as i, extractUsedControlValues as l, ProjectionOf as m, ArbacUserProviderToken as n, AsArbacDbController as o, OwnFieldKey as p, AoothArbacClaims as r, applyAllowedFieldsAndSet as s, ArbacUserProvider as t, ControlsOf as u };
+export { ProjectionOf as _, conjoinArbacDbScopes as a, TArbacMeta as b, ArbacDbScope as c, extractUsedControlValues as d, applyAllowedFieldsAndSet as f, OwnFieldKey as g, NavTarget as h, ConjoinArbacDbScopesOptions as i, AsArbacDbController as l, NavRelationKey as m, ArbacUserProviderToken as n, RefForeignKey as o, ControlsOf as p, AoothArbacClaims as r, RefTableSource as s, ArbacUserProvider as t, enforceControlsPolicy as u, ARBAC_DELEGATED_AUTH as v, getArbacMate as x, ArbacDelegatedAuth as y };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aooth/arbac-moost",
-  "version": "0.1.71",
+  "version": "0.1.72",
   "description": "Moost RBAC integration for aoothjs (migrated from @moostjs/arbac)",
   "keywords": [
     "abac",
@@ -61,30 +61,30 @@
   },
   "dependencies": {
     "@uniqu/core": "^0.1.11",
-    "@aooth/arbac": "0.1.71",
-    "@aooth/user": "0.1.71",
-    "@aooth/arbac-core": "0.1.71"
+    "@aooth/arbac": "0.1.72",
+    "@aooth/user": "0.1.72",
+    "@aooth/arbac-core": "0.1.72"
   },
   "devDependencies": {
-    "@atscript/core": "^0.1.95",
-    "@atscript/db": "^0.1.142",
-    "@atscript/db-sql-tools": "^0.1.142",
-    "@atscript/db-sqlite": "^0.1.142",
-    "@atscript/moost-db": "^0.1.142",
-    "@atscript/typescript": "^0.1.95",
-    "@moostjs/event-http": "^0.6.39",
+    "@atscript/core": "^0.1.97",
+    "@atscript/db": "^0.1.145",
+    "@atscript/db-sql-tools": "^0.1.145",
+    "@atscript/db-sqlite": "^0.1.145",
+    "@atscript/moost-db": "^0.1.145",
+    "@atscript/typescript": "^0.1.97",
+    "@moostjs/event-http": "^0.6.41",
     "@types/better-sqlite3": "^7.6.13",
     "better-sqlite3": "^12.6.2",
-    "unplugin-atscript": "^0.1.95"
+    "unplugin-atscript": "^0.1.97"
   },
   "peerDependencies": {
-    "@atscript/db": "^0.1.142",
-    "@atscript/moost-db": "^0.1.142",
-    "@atscript/typescript": "^0.1.95",
-    "@moostjs/event-http": "^0.6.39",
-    "@wooksjs/event-core": "^0.7.23",
-    "@wooksjs/event-http": "^0.7.23",
-    "moost": "^0.6.39"
+    "@atscript/db": "^0.1.145",
+    "@atscript/moost-db": "^0.1.145",
+    "@atscript/typescript": "^0.1.97",
+    "@moostjs/event-http": "^0.6.41",
+    "@wooksjs/event-core": "^0.7.24",
+    "@wooksjs/event-http": "^0.7.24",
+    "moost": "^0.6.41"
   },
   "peerDependenciesMeta": {
     "@atscript/db": {