@diister/quick-permission 0.9.0-beta.5

package/dist/indirect-resource.js

@@ -0,0 +1,109 @@
+/**
+ * `indirectResource` — déclaration d'une ressource atteignable via une
+ * jointure (DB-pushdown via aggregation pipeline). Pendant de `resource()`
+ * pour les cas où la donnée filtrante vit dans une autre collection (ou
+ * dans la même via un foreign field).
+ *
+ * Cas d'usage typique :
+ *  - lister les `participant` qui ont une `org_membership` matching org=X
+ *  - lister les `participant` dont l'`user` lié appartient à entreprise=Y
+ *  - chaîner sur plusieurs niveaux (`participant → user → entreprise_member`)
+ *
+ * La méthode `.match()` retourne une `Rule` sentinelle (kind="indirect-match")
+ * que l'orchestrateur de `system.ts` détecte pour générer le pipeline
+ * d'aggregation correspondant — voir `indirect-aggregation.ts`.
+ *
+ * À la différence des ressources directes :
+ *  - Pas de `fetch` ni de `dedupKey` : aucune donnée chargée à l'évaluation
+ *  - Pas de rule `filter`/`include`/`require*` — uniquement `match` pour
+ *    contribuer une contrainte au pipeline généré.
+ */
+import { defineRule } from "./rules.js";
+import { evaluateSpec, validateSpec } from "./mongo-query.js";
+/**
+ * Sentinelle dans `Rule.descriptor` pour qu'`system.ts` reconnaisse
+ * cette rule comme "indirect" et collecte la resource correspondante.
+ *
+ * Le champ est typé `unknown` côté `RuleDescriptor` parce que
+ * `[extra: string]: unknown` est la signature catch-all des descriptors —
+ * on cast à l'extraction.
+ */
+export const INDIRECT_RULE_KIND = "indirect-match";
+export function indirectResource(spec) {
+    // Normalize `from`: a `Resource` (from `resource({...})`) has no `kind`
+    // field; we treat it as "direct". An `IndirectResource` has
+    // `kind: "indirect"` set by this very factory. Walking the chain in
+    // the orchestrator reads `from.kind` to know whether to descend.
+    const fromNormalized = {
+        id: spec.from.id,
+        kind: spec.from.kind === "indirect"
+            ? "indirect"
+            : "direct",
+    };
+    const impl = {
+        id: spec.id,
+        kind: "indirect",
+        from: fromNormalized,
+        on: spec.on,
+        to: spec.to,
+        cardinality: spec.cardinality,
+        fetcher: spec.fetch,
+        cacheKeyForTarget(target) {
+            // Mirror of Resource.cacheKeyForTarget — the indirect's cache key
+            // is target-derived (typically by source dedup). Useful for
+            // `CanContext.preseed()` when the caller wants to inject joined
+            // docs already returned by a pipeline aggregation.
+            return `${spec.id}::${JSON.stringify(target)}`;
+        },
+        match() {
+            return defineRule({
+                kind: INDIRECT_RULE_KIND,
+                needs: [],
+                describe: () => ({ indirectResource: impl }),
+                check: (_data, _payload, ctx) => {
+                    // Cap-mode : sentinelle. `system.ts` reads the descriptor and
+                    // emits the pipeline via `buildAggregationStages`. The rule
+                    // itself contributes nothing.
+                    if (ctx.capability)
+                        return { ok: true };
+                    // Concrete mode without fetcher : sentinelle aussi (legacy).
+                    if (!impl.fetcher)
+                        return { ok: true };
+                    // Concrete mode with fetcher : evaluate `grant.with[id]` spec
+                    // against the joined docs. The engine already populated the
+                    // joined docs in the context cache (see system.ts) — we just
+                    // read them from `_indirectFetched` (an opaque per-rule pass).
+                    // If no spec is set, the rule passes (the grant trusts the
+                    // indirect resource without further check).
+                    const spec = ctx.grant.with?.[impl.id];
+                    if (spec === undefined)
+                        return { ok: true };
+                    if (typeof spec === "object" && spec !== null)
+                        validateSpec(spec);
+                    const joined = ctx._indirectFetched?.get(impl.id) ?? [];
+                    const passes = joined.some((d) => evaluateSpec(spec, d));
+                    return passes
+                        ? { ok: true }
+                        : {
+                            ok: false,
+                            reason: `indirect[${impl.id}] no joined doc matches spec`,
+                        };
+                },
+            });
+        },
+    };
+    return impl;
+}
+/**
+ * Extraction utilitaire pour `system.ts` : récupère la `IndirectResource`
+ * portée par une rule sentinelle, ou `null` si la rule n'en est pas une.
+ */
+export function extractIndirectResource(rule) {
+    if (rule.descriptor.kind !== INDIRECT_RULE_KIND)
+        return null;
+    const ref = rule.descriptor.indirectResource;
+    if (!ref || typeof ref !== "object")
+        return null;
+    return ref;
+}
+//# sourceMappingURL=indirect-resource.js.map

package/dist/indirect-resource.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"indirect-resource.js","sourceRoot":"","sources":["../indirect-resource.ts"],"names":[],"mappings":"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"}

package/dist/mod.d.ts

@@ -0,0 +1,25 @@
+/**
+ * `@diister/quick-permission` — API publique.
+ *
+ * Expose une primitive unique `defineRule({ needs, check })` autour de
+ * laquelle sont organisés les `Resource`, méthodes de sucre, et le moteur
+ * d'orchestration avec dedup par contexte.
+ *
+ * Cf. `docs/rfc-resource-pipe-api.md` pour la motivation, les décisions
+ * de design et le plan de migration.
+ */
+export { seg, target } from "./target.ts";
+export type { AnySegment, AnyTarget, CanResult, FetchCtx, FilterContribution, Grant, IndirectResourceInfo, ListEntry, Permission, Resource, ResourceData, ResourcesData, Rule, RuleDescriptor, RuleResult, SegmentSpec, SerializableSegment, SerializableTarget, SpecToSegment, Subject, TargetArgs, TargetNone, TargetOptional, TargetPath, TargetRequired, TreeNode, } from "./types.ts";
+export { resource } from "./resource.ts";
+export { indirectResource } from "./indirect-resource.ts";
+export type { IndirectResource, IndirectResourceJoin, } from "./indirect-resource.ts";
+export type { AggregationStage } from "./indirect-aggregation.ts";
+export { defineRule, inputMatch, matchPath, requireSelf } from "./rules.ts";
+export type { DefineRuleOpts } from "./rules.ts";
+export { intermediate, permission } from "./permission.ts";
+export type { IntermediateBuilder, IntermediateConfig, PermissionBuilder, PermissionConfig, } from "./permission.ts";
+export { createSystem } from "./system.ts";
+export type { CanContext, Provider, ProviderFn, ProviderObject, System, } from "./system.ts";
+export { applyFilter, pickFields } from "./core/filtering.ts";
+export type { FilterSpec } from "./core/merging.ts";
+//# sourceMappingURL=mod.d.ts.map

package/dist/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../mod.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAG1C,YAAY,EACV,UAAU,EACV,SAAS,EACT,SAAS,EACT,QAAQ,EACR,kBAAkB,EAClB,KAAK,EACL,oBAAoB,EACpB,SAAS,EACT,UAAU,EACV,QAAQ,EACR,YAAY,EACZ,aAAa,EACb,IAAI,EACJ,cAAc,EACd,UAAU,EACV,WAAW,EACX,mBAAmB,EACnB,kBAAkB,EAClB,aAAa,EACb,OAAO,EACP,UAAU,EACV,UAAU,EACV,cAAc,EACd,UAAU,EACV,cAAc,EACd,QAAQ,GACT,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAGzC,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,YAAY,EACV,gBAAgB,EAChB,oBAAoB,GACrB,MAAM,wBAAwB,CAAC;AAChC,YAAY,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAGlE,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC5E,YAAY,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAGjD,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC3D,YAAY,EACV,mBAAmB,EACnB,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,YAAY,EACV,UAAU,EACV,QAAQ,EACR,UAAU,EACV,cAAc,EACd,MAAM,GACP,MAAM,aAAa,CAAC;AAGrB,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC9D,YAAY,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/mod.js

@@ -0,0 +1,25 @@
+/**
+ * `@diister/quick-permission` — API publique.
+ *
+ * Expose une primitive unique `defineRule({ needs, check })` autour de
+ * laquelle sont organisés les `Resource`, méthodes de sucre, et le moteur
+ * d'orchestration avec dedup par contexte.
+ *
+ * Cf. `docs/rfc-resource-pipe-api.md` pour la motivation, les décisions
+ * de design et le plan de migration.
+ */
+// ─── Targets ─────────────────────────────────────────────────────────────
+export { seg, target } from "./target.js";
+// ─── Resource factory + sugar methods ────────────────────────────────────
+export { resource } from "./resource.js";
+// ─── Indirect resource (JOIN-based, generates aggregation pipeline) ──────
+export { indirectResource } from "./indirect-resource.js";
+// ─── defineRule + standalone helpers ─────────────────────────────────────
+export { defineRule, inputMatch, matchPath, requireSelf } from "./rules.js";
+// ─── Permission builders ─────────────────────────────────────────────────
+export { intermediate, permission } from "./permission.js";
+// ─── System ──────────────────────────────────────────────────────────────
+export { createSystem } from "./system.js";
+// ─── Field-projection helpers (used outside permission checks too) ───────
+export { applyFilter, pickFields } from "./core/filtering.js";
+//# sourceMappingURL=mod.js.map

package/dist/mod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.js","sourceRoot":"","sources":["../mod.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,4EAA4E;AAC5E,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAgC1C,4EAA4E;AAC5E,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC,4EAA4E;AAC5E,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAO1D,4EAA4E;AAC5E,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAG5E,4EAA4E;AAC5E,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAQ3D,4EAA4E;AAC5E,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAS3C,4EAA4E;AAC5E,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/mongo-query.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Évaluateur d'expressions style MongoDB query basé sur `sift`.
+ *
+ * Sift supporte ~100% du Mongo query language en pur JS. On délègue
+ * l'évaluation à sift mais on **valide la spec en amont** pour s'assurer
+ * qu'aucun opérateur dangereux n'est utilisé (`$where`, `$function`, etc.
+ * permettent de l'exécution de code arbitraire — interdits dans un grant
+ * qui peut venir de la DB).
+ *
+ * Whitelist :
+ *   - Comparaisons : `$eq`, `$ne`, `$in`, `$nin`, `$gt`, `$gte`, `$lt`, `$lte`
+ *   - Existence    : `$exists`, `$type`
+ *   - Logiques     : `$and`, `$or`, `$nor`, `$not`
+ *   - String       : `$regex`, `$options`
+ *   - Tableaux     : `$all`, `$elemMatch`, `$size`
+ *
+ * Interdit (pas dans la whitelist, throw au boot ou au check) :
+ *   - `$where`, `$function`, `$expr`, `$jsonSchema`, `$accumulator`
+ *
+ * La même spec sert à :
+ *  1. Évaluer en mémoire un document (per-doc check via sift)
+ *  2. Filtrer une collection MongoDB en pushdown (la spec EST déjà du Mongo)
+ */
+export type MongoSpec = Record<string, unknown>;
+/**
+ * Vérifie récursivement qu'aucun opérateur non-whitelisté n'est présent
+ * dans la spec. Throw au premier opérateur interdit (`$where`, etc.).
+ *
+ * À appeler à la création du grant (validation côté API) ou au pire au
+ * check time, pour empêcher l'exécution de code arbitraire.
+ */
+export declare function validateSpec(spec: unknown, path?: string): void;
+/**
+ * Évalue une spec contre un document. La spec est validée d'abord pour
+ * rejeter tout opérateur non-whitelisté.
+ */
+export declare function evaluateSpec(spec: MongoSpec, doc: unknown): boolean;
+//# sourceMappingURL=mongo-query.d.ts.map

package/dist/mongo-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mongo-query.d.ts","sourceRoot":"","sources":["../mongo-query.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AA+BH,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEhD;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,SAAM,GAAG,IAAI,CAqB5D;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,SAAS,EAAE,GAAG,EAAE,OAAO,GAAG,OAAO,CAInE"}

package/dist/mongo-query.js

@@ -0,0 +1,88 @@
+/**
+ * Évaluateur d'expressions style MongoDB query basé sur `sift`.
+ *
+ * Sift supporte ~100% du Mongo query language en pur JS. On délègue
+ * l'évaluation à sift mais on **valide la spec en amont** pour s'assurer
+ * qu'aucun opérateur dangereux n'est utilisé (`$where`, `$function`, etc.
+ * permettent de l'exécution de code arbitraire — interdits dans un grant
+ * qui peut venir de la DB).
+ *
+ * Whitelist :
+ *   - Comparaisons : `$eq`, `$ne`, `$in`, `$nin`, `$gt`, `$gte`, `$lt`, `$lte`
+ *   - Existence    : `$exists`, `$type`
+ *   - Logiques     : `$and`, `$or`, `$nor`, `$not`
+ *   - String       : `$regex`, `$options`
+ *   - Tableaux     : `$all`, `$elemMatch`, `$size`
+ *
+ * Interdit (pas dans la whitelist, throw au boot ou au check) :
+ *   - `$where`, `$function`, `$expr`, `$jsonSchema`, `$accumulator`
+ *
+ * La même spec sert à :
+ *  1. Évaluer en mémoire un document (per-doc check via sift)
+ *  2. Filtrer une collection MongoDB en pushdown (la spec EST déjà du Mongo)
+ */
+import sift from "./sift/index.js";
+const ALLOWED_OPERATORS = new Set([
+    // Comparison
+    "$eq",
+    "$ne",
+    "$in",
+    "$nin",
+    "$gt",
+    "$gte",
+    "$lt",
+    "$lte",
+    // Existence / type
+    "$exists",
+    "$type",
+    // Logical
+    "$and",
+    "$or",
+    "$nor",
+    "$not",
+    // String
+    "$regex",
+    "$options",
+    // Array
+    "$all",
+    "$elemMatch",
+    "$size",
+]);
+/**
+ * Vérifie récursivement qu'aucun opérateur non-whitelisté n'est présent
+ * dans la spec. Throw au premier opérateur interdit (`$where`, etc.).
+ *
+ * À appeler à la création du grant (validation côté API) ou au pire au
+ * check time, pour empêcher l'exécution de code arbitraire.
+ */
+export function validateSpec(spec, path = "$") {
+    if (spec === null || typeof spec !== "object")
+        return;
+    if (Array.isArray(spec)) {
+        // A `for` loop, not `forEach`: the arrow's implicit return handed back
+        // validateSpec's value, which the iteration then discarded.
+        for (const [i, item] of spec.entries()) {
+            validateSpec(item, `${path}[${i}]`);
+        }
+        return;
+    }
+    for (const [key, value] of Object.entries(spec)) {
+        if (key.startsWith("$")) {
+            if (!ALLOWED_OPERATORS.has(key)) {
+                throw new Error(`Forbidden Mongo operator at ${path}: "${key}". ` +
+                    `Allowed: ${[...ALLOWED_OPERATORS].join(", ")}`);
+            }
+        }
+        validateSpec(value, `${path}.${key}`);
+    }
+}
+/**
+ * Évalue une spec contre un document. La spec est validée d'abord pour
+ * rejeter tout opérateur non-whitelisté.
+ */
+export function evaluateSpec(spec, doc) {
+    validateSpec(spec);
+    // deno-lint-ignore no-explicit-any
+    return sift(spec)(doc);
+}
+//# sourceMappingURL=mongo-query.js.map

package/dist/mongo-query.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mongo-query.js","sourceRoot":"","sources":["../mongo-query.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,IAAI,MAAM,iBAAiB,CAAC;AAEnC,MAAM,iBAAiB,GAAwB,IAAI,GAAG,CAAC;IACrD,aAAa;IACb,KAAK;IACL,KAAK;IACL,KAAK;IACL,MAAM;IACN,KAAK;IACL,MAAM;IACN,KAAK;IACL,MAAM;IACN,mBAAmB;IACnB,SAAS;IACT,OAAO;IACP,UAAU;IACV,MAAM;IACN,KAAK;IACL,MAAM;IACN,MAAM;IACN,SAAS;IACT,QAAQ;IACR,UAAU;IACV,QAAQ;IACR,MAAM;IACN,YAAY;IACZ,OAAO;CACR,CAAC,CAAC;AAIH;;;;;;GAMG;AACH,MAAM,UAAU,YAAY,CAAC,IAAa,EAAE,IAAI,GAAG,GAAG;IACpD,IAAI,IAAI,KAAK,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ;QAAE,OAAO;IACtD,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;QACxB,uEAAuE;QACvE,4DAA4D;QAC5D,KAAK,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC;YACvC,YAAY,CAAC,IAAI,EAAE,GAAG,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC;QACtC,CAAC;QACD,OAAO;IACT,CAAC;IACD,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAc,CAAC,EAAE,CAAC;QAC1D,IAAI,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;YACxB,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;gBAChC,MAAM,IAAI,KAAK,CACb,+BAA+B,IAAI,MAAM,GAAG,KAAK;oBAC/C,YAAY,CAAC,GAAG,iBAAiB,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAClD,CAAC;YACJ,CAAC;QACH,CAAC;QACD,YAAY,CAAC,KAAK,EAAE,GAAG,IAAI,IAAI,GAAG,EAAE,CAAC,CAAC;IACxC,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,YAAY,CAAC,IAAe,EAAE,GAAY;IACxD,YAAY,CAAC,IAAI,CAAC,CAAC;IACnB,mCAAmC;IACnC,OAAQ,IAAY,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;AAClC,CAAC"}

package/dist/permission.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Builder de permission pour resource-pipe.
+ *
+ * API en deux étapes (`permission(opts).rules([])`), même justification que
+ * `library/permission.ts` (cf. RFC declarative §"Décision two-call").
+ *
+ * Différence majeure vs l'API declarative actuelle : pas de slot `fetch` au
+ * niveau permission. Les fetches sont déclarés au niveau des `Resource`s
+ * que les rules consomment via `needs`.
+ */
+import type { AnyTarget, Grant, Permission, Rule } from "./types.ts";
+export type PermissionConfig<TMeta> = {
+    readonly metadata?: TMeta;
+    readonly target: AnyTarget;
+};
+export type PermissionBuilder<TMeta> = {
+    rules(rules: readonly Rule[]): Permission<TMeta>;
+};
+/**
+ * Déclare une permission "feuille" (vérifiable directement via `can()`).
+ *
+ * @example
+ *   "users.read": permission({
+ *     metadata: { description: "Lire un user" },
+ *     target: target.required("user"),
+ *   }).rules([
+ *     userOf.match(),
+ *     userOf.filter(),
+ *   ]),
+ */
+export declare function permission<TMeta = unknown>(config: PermissionConfig<TMeta>): PermissionBuilder<TMeta>;
+export type IntermediateConfig<TMeta> = {
+    readonly metadata?: TMeta;
+    readonly target: AnyTarget;
+    /** Expand un grant sur cette intermediate en N grants sur les enfants. */
+    readonly expandsTo: (grant: Grant) => readonly Grant[];
+};
+export type IntermediateBuilder<TMeta> = {
+    /** Optionnellement attacher des rules au niveau intermediate. */
+    rules(rules: readonly Rule[]): Permission<TMeta>;
+};
+/**
+ * Déclare une permission "intermediate" (macro qui s'expand en grants
+ * enfants au moment du check).
+ *
+ * @example
+ *   "users.manage": intermediate({
+ *     target: target.required("user"),
+ *     expandsTo: (grant) => [
+ *       { ...grant, key: "users.read" },
+ *       { ...grant, key: "users.update" },
+ *       { ...grant, key: "users.delete" },
+ *     ],
+ *   }).rules([]),
+ */
+export declare function intermediate<TMeta = unknown>(config: IntermediateConfig<TMeta>): IntermediateBuilder<TMeta>;
+//# sourceMappingURL=permission.d.ts.map

package/dist/permission.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permission.d.ts","sourceRoot":"","sources":["../permission.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAErE,MAAM,MAAM,gBAAgB,CAAC,KAAK,IAAI;IACpC,QAAQ,CAAC,QAAQ,CAAC,EAAE,KAAK,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,iBAAiB,CAAC,KAAK,IAAI;IACrC,KAAK,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC;CAClD,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,KAAK,GAAG,OAAO,EACxC,MAAM,EAAE,gBAAgB,CAAC,KAAK,CAAC,GAC9B,iBAAiB,CAAC,KAAK,CAAC,CAU1B;AAED,MAAM,MAAM,kBAAkB,CAAC,KAAK,IAAI;IACtC,QAAQ,CAAC,QAAQ,CAAC,EAAE,KAAK,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAC3B,0EAA0E;IAC1E,QAAQ,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,SAAS,KAAK,EAAE,CAAC;CACxD,CAAC;AAEF,MAAM,MAAM,mBAAmB,CAAC,KAAK,IAAI;IACvC,iEAAiE;IACjE,KAAK,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC;CAClD,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAAC,KAAK,GAAG,OAAO,EAC1C,MAAM,EAAE,kBAAkB,CAAC,KAAK,CAAC,GAChC,mBAAmB,CAAC,KAAK,CAAC,CAW5B"}

package/dist/permission.js

@@ -0,0 +1,60 @@
+/**
+ * Builder de permission pour resource-pipe.
+ *
+ * API en deux étapes (`permission(opts).rules([])`), même justification que
+ * `library/permission.ts` (cf. RFC declarative §"Décision two-call").
+ *
+ * Différence majeure vs l'API declarative actuelle : pas de slot `fetch` au
+ * niveau permission. Les fetches sont déclarés au niveau des `Resource`s
+ * que les rules consomment via `needs`.
+ */
+/**
+ * Déclare une permission "feuille" (vérifiable directement via `can()`).
+ *
+ * @example
+ *   "users.read": permission({
+ *     metadata: { description: "Lire un user" },
+ *     target: target.required("user"),
+ *   }).rules([
+ *     userOf.match(),
+ *     userOf.filter(),
+ *   ]),
+ */
+export function permission(config) {
+    return {
+        rules(rules) {
+            return {
+                metadata: config.metadata,
+                target: config.target,
+                rules,
+            };
+        },
+    };
+}
+/**
+ * Déclare une permission "intermediate" (macro qui s'expand en grants
+ * enfants au moment du check).
+ *
+ * @example
+ *   "users.manage": intermediate({
+ *     target: target.required("user"),
+ *     expandsTo: (grant) => [
+ *       { ...grant, key: "users.read" },
+ *       { ...grant, key: "users.update" },
+ *       { ...grant, key: "users.delete" },
+ *     ],
+ *   }).rules([]),
+ */
+export function intermediate(config) {
+    return {
+        rules(rules) {
+            return {
+                metadata: config.metadata,
+                target: config.target,
+                rules,
+                expandsTo: config.expandsTo,
+            };
+        },
+    };
+}
+//# sourceMappingURL=permission.js.map

package/dist/permission.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"permission.js","sourceRoot":"","sources":["../permission.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAaH;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,UAAU,CACxB,MAA+B;IAE/B,OAAO;QACL,KAAK,CAAC,KAAK;YACT,OAAO;gBACL,QAAQ,EAAE,MAAM,CAAC,QAAQ;gBACzB,MAAM,EAAE,MAAM,CAAC,MAAM;gBACrB,KAAK;aACN,CAAC;QACJ,CAAC;KACF,CAAC;AACJ,CAAC;AAcD;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,YAAY,CAC1B,MAAiC;IAEjC,OAAO;QACL,KAAK,CAAC,KAAK;YACT,OAAO;gBACL,QAAQ,EAAE,MAAM,CAAC,QAAQ;gBACzB,MAAM,EAAE,MAAM,CAAC,MAAM;gBACrB,KAAK;gBACL,SAAS,EAAE,MAAM,CAAC,SAAS;aAC5B,CAAC;QACJ,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/resource.d.ts

@@ -0,0 +1,48 @@
+/**
+ * `Resource` : source de donnée fetchable, dédupliquée par contexte.
+ *
+ * Une Resource est conçue pour être déclarée une fois dans son domaine
+ * (`userOf`, `expositionInfoOf`, etc.) et réutilisée entre permissions.
+ * Le moteur dédup les fetches au sein d'un context via `(id, dedupKey)`.
+ *
+ * Les méthodes `match`/`filter`/`includes`/`require*` sont du sucre :
+ * elles produisent des Rule via `defineRule`, avec la resource comme need.
+ *
+ * ─── Capability-mode contract ────────────────────────────────────────────
+ * A request target containing a wildcard (`"*"` or `"xxx:*"`) is a capability
+ * query — "can the subject act on ANY resource of this shape?". The engine
+ * skips resource fetches in this mode (no concrete resource to fetch). Each
+ * rule must declare what it does when its data is unavailable:
+ *
+ *   match           : silent-pass (cannot verify spec against absent data),
+ *                     but exposes the spec as a constraint for DB pushdown.
+ *   filter          : silent-pass — no projection happens; `output.data`
+ *                     stays undefined.
+ *   includes        : deny — membership cannot be checked without the resource.
+ *   requireTruthy   : deny — no value to test for truthiness.
+ *   requireOwner    : deny — no owner field to compare.
+ *   requireMembership: deny — no membership list to scan.
+ *   requireCustom   : deny — predicate cannot run without `data`.
+ *
+ * Pure rules (no `needs`) like `matchPath` and `requireSelf` are unaffected:
+ * they read `ctx.target` / `ctx.subject` only.
+ */
+import type { FetchCtx, Grant, Resource } from "./types.ts";
+/**
+ * Crée une Resource. À utiliser une fois par entité de domaine, partagée
+ * entre toutes les permissions qui la consomment.
+ *
+ * @example
+ *   const userOf = resource({
+ *     id: "user",
+ *     fetch: ({ target }) => usersRepo.findById(target[0] as string),
+ *     dedupKey: ({ target }) => target[0] as string,
+ *   });
+ */
+export declare function resource<T>(opts: {
+    readonly id: string;
+    readonly fetch: (ctx: FetchCtx) => T | Promise<T>;
+    readonly activeWhen?: (grant: Grant) => boolean;
+    readonly dedupKey?: (ctx: FetchCtx) => string;
+}): Resource<T>;
+//# sourceMappingURL=resource.d.ts.map

package/dist/resource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource.d.ts","sourceRoot":"","sources":["../resource.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,EAAQ,MAAM,YAAY,CAAC;AA0SlE;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE;IAChC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,CAAC,GAAG,EAAE,QAAQ,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAClD,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC;IAChD,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,QAAQ,KAAK,MAAM,CAAC;CAC/C,GAAG,QAAQ,CAAC,CAAC,CAAC,CAOd"}