foldkit-guard 0.6.0 → 0.8.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (36) hide show
  1. package/README.md +223 -46
  2. package/dist/agent.d.mts +1 -1
  3. package/dist/agent.mjs +1 -1
  4. package/dist/{attach-CRCF5XHS.mjs → attach-CEGlbWu5.mjs} +17 -2
  5. package/dist/attach-CEGlbWu5.mjs.map +1 -0
  6. package/dist/{attach-BepaL930.d.mts → attach-CJl-GtbN.d.mts} +156 -10
  7. package/dist/attach-CJl-GtbN.d.mts.map +1 -0
  8. package/dist/{condition-Dx54lL7v.mjs → condition-dNSbUHzE.mjs} +98 -10
  9. package/dist/condition-dNSbUHzE.mjs.map +1 -0
  10. package/dist/drizzle.d.mts +1 -1
  11. package/dist/drizzle.mjs +8 -6
  12. package/dist/drizzle.mjs.map +1 -1
  13. package/dist/index.d.mts +1 -1
  14. package/dist/index.mjs +34 -17
  15. package/dist/index.mjs.map +1 -1
  16. package/dist/may-DprCmMgK.mjs +200 -0
  17. package/dist/may-DprCmMgK.mjs.map +1 -0
  18. package/dist/{me-BYpuVqJE.mjs → me-C-gX1paZ.mjs} +3 -3
  19. package/dist/{me-BYpuVqJE.mjs.map → me-C-gX1paZ.mjs.map} +1 -1
  20. package/dist/media.d.mts +1 -1
  21. package/dist/{placed-BvdNmZJu.mjs → placed-CGyo-NRR.mjs} +2 -2
  22. package/dist/{placed-BvdNmZJu.mjs.map → placed-CGyo-NRR.mjs.map} +1 -1
  23. package/dist/server.d.mts +54 -20
  24. package/dist/server.d.mts.map +1 -1
  25. package/dist/server.mjs +288 -154
  26. package/dist/server.mjs.map +1 -1
  27. package/dist/sync.d.mts +5 -3
  28. package/dist/sync.d.mts.map +1 -1
  29. package/dist/sync.mjs +18 -8
  30. package/dist/sync.mjs.map +1 -1
  31. package/package.json +20 -19
  32. package/dist/attach-BepaL930.d.mts.map +0 -1
  33. package/dist/attach-CRCF5XHS.mjs.map +0 -1
  34. package/dist/condition-Dx54lL7v.mjs.map +0 -1
  35. package/dist/may-DzCAt_5M.mjs +0 -75
  36. package/dist/may-DzCAt_5M.mjs.map +0 -1
@@ -1,12 +1,15 @@
1
1
  import { Context, Effect, Option, Schema } from "effect";
2
- import { AnyEntity, AnyQuery, Entity, InputExpr, MemoryOperators, Predicate } from "foldkit-entity";
2
+ import { AnyEntity, AnyQuery, Entity, EntityRef, ExprContext, Forbids, HeldRow, HeldRows, InputExpr, Invalid, MemoryOperators, Predicate, Predict, ReadsOf } from "foldkit-entity";
3
3
  type Condition = {
4
4
  readonly _tag: 'Always';
5
5
  } | {
6
6
  readonly _tag: 'Never';
7
- } | {
7
+ } |
8
+ /** A row guard, and what its `Expr.viewer` reads: the principal it was decided for. */
9
+ {
8
10
  readonly _tag: 'Row';
9
11
  readonly guard: RowGuard<any, AnyEntity>;
12
+ readonly context: ExprContext;
10
13
  } |
11
14
  /** The row its `one` relation points at is readable. */
12
15
  {
@@ -43,6 +46,34 @@ declare const Condition: {
43
46
  * can deny it, never end the request.
44
47
  */
45
48
  holds: (condition: Condition, values: Readonly<Record<string, unknown>>, input: Readonly<Record<string, unknown>>, inherit: (relation: string) => boolean, operators: MemoryOperators) => boolean;
49
+ /**
50
+ * `condition` decided over one row as far as one row can: each row guard
51
+ * over the row alone judged (`holds`), an inherited Read refused, as a
52
+ * writer refuses one, and each row guard that reads another row (a path, an
53
+ * exists) kept for a statement to judge. `Always` or `Never` when the row
54
+ * alone decides it.
55
+ */
56
+ residual: (condition: Condition, values: Readonly<Record<string, unknown>>, input: Readonly<Record<string, unknown>>, operators: MemoryOperators) => Condition;
57
+ /** `Always` and `Never` as what one row decided; none where a statement must judge the rest. */
58
+ decided: (condition: Condition) => Option.Option<boolean>;
59
+ /**
60
+ * The members of `written`, the row a write changes, that a condition's
61
+ * guards reading another row start from: each one's fields, the relation
62
+ * each path leaves by, and, where `written` is the viewer's own row, what a
63
+ * path from the viewer leaves it by. A write that changes one would need the
64
+ * guard judged over the row it leaves, which a statement over the stored row
65
+ * does not do.
66
+ */
67
+ reachedFrom: (condition: Condition, written: EntityRef) => ReadonlyArray<string>;
68
+ /**
69
+ * Whether a row a client holds meets `condition`, a part it cannot decide
70
+ * taken to be `assumed`: a row guard over the principal's fields, which a
71
+ * client is not given, an inherited Read, and a rule over a row or field
72
+ * the holder lacks. A row guard reads the holder's rows (`rows`) where it
73
+ * follows a path from the viewer. Run once assuming each way, it is decided
74
+ * where both agree, since no part of a condition is negated.
75
+ */
76
+ judge: (condition: Condition, row: HeldRow, rows: HeldRows, assumed: boolean) => boolean;
46
77
  /**
47
78
  * `condition` with every row guard that reads one of `unset`, and every
48
79
  * relation of them it follows, refused: a field a create leaves unset
@@ -85,11 +116,28 @@ declare const May: {
85
116
  /**
86
117
  * Adds the `may` member to an Entity, after its guards are attached:
87
118
  * `TodoFields.pipe(Guards.attach(G, { … }), Guards.may)`. Select it as any
88
- * member (`may: true`); `GuardServer.filter` answers it.
119
+ * member (`may: true`); `GuardServer.filter` answers it. A client holding it
120
+ * refuses, where it is made, a write it says no to (`Forbidden`).
89
121
  */
90
122
  member: <E extends AnyEntity>(entity: E & ("may" & keyof E["members"] extends never ? unknown : {
91
123
  readonly alreadyAMember: "may" & keyof E["members"];
92
- })) => E extends Entity<infer Name extends string, infer Fields extends Schema.Struct.Fields, infer R extends Readonly<Record<string, import("foldkit-entity").RelationSpec<AnyEntity, import("foldkit-entity").Cardinality, boolean>>>, infer D extends Readonly<Record<string, import("foldkit-entity").DerivedSpec<Schema.Constraint>>>> ? Entity<Name, Fields, R, D & {
124
+ })) => E extends import("foldkit-entity").VariantEntity<infer Name extends string, infer Fields extends Schema.Struct.Fields, infer R extends Readonly<Record<string, import("foldkit-entity").RelationSpec<AnyEntity, import("foldkit-entity").Cardinality, boolean>>>, infer D extends Readonly<Record<string, import("foldkit-entity").DerivedSpec<Schema.Constraint, {
125
+ readonly _tag: "Count";
126
+ readonly relation: import("foldkit-entity").EntityRelation<string, string, AnyEntity, "one", boolean>;
127
+ } | {
128
+ readonly _tag: "Exists";
129
+ readonly relation: import("foldkit-entity").EntityRelation<string, string, AnyEntity, "one", boolean>;
130
+ readonly viewer: import("foldkit-entity").EntityRelation<string, string, AnyEntity, "one", boolean>;
131
+ } | {
132
+ readonly _tag: "Supplied";
133
+ readonly predict: Option.Option<Predict>;
134
+ readonly forbids: Option.Option<Forbids>;
135
+ }>>>, infer U extends Schema.Top & {
136
+ readonly tag: '_tag';
137
+ readonly cases: Readonly<Record<string, {
138
+ readonly fields: Schema.Struct.Fields;
139
+ }>>;
140
+ }> ? import("foldkit-entity").VariantEntity<Name, Fields, R, D & {
93
141
  readonly may: import("foldkit-entity").DerivedSpec<Schema.Struct<{
94
142
  readonly row: Schema.$Record<Schema.String, Schema.Boolean>;
95
143
  readonly reasons: Schema.$Record<Schema.String, Schema.String>;
@@ -98,7 +146,36 @@ declare const May: {
98
146
  readonly Link: Schema.Boolean;
99
147
  readonly Unlink: Schema.Boolean;
100
148
  }>>;
101
- }>>;
149
+ }>, {
150
+ readonly _tag: "Supplied";
151
+ readonly predict: Option.Option<Predict>;
152
+ readonly forbids: Option.Option<Forbids>;
153
+ }>;
154
+ }, U> : E extends Entity<infer Name_1 extends string, infer Fields_1 extends Schema.Struct.Fields, infer R_1 extends Readonly<Record<string, import("foldkit-entity").RelationSpec<AnyEntity, import("foldkit-entity").Cardinality, boolean>>>, infer D_1 extends Readonly<Record<string, import("foldkit-entity").DerivedSpec<Schema.Constraint, {
155
+ readonly _tag: "Count";
156
+ readonly relation: import("foldkit-entity").EntityRelation<string, string, AnyEntity, "one", boolean>;
157
+ } | {
158
+ readonly _tag: "Exists";
159
+ readonly relation: import("foldkit-entity").EntityRelation<string, string, AnyEntity, "one", boolean>;
160
+ readonly viewer: import("foldkit-entity").EntityRelation<string, string, AnyEntity, "one", boolean>;
161
+ } | {
162
+ readonly _tag: "Supplied";
163
+ readonly predict: Option.Option<Predict>;
164
+ readonly forbids: Option.Option<Forbids>;
165
+ }>>>> ? Entity<Name_1, Fields_1, R_1, D_1 & {
166
+ readonly may: import("foldkit-entity").DerivedSpec<Schema.Struct<{
167
+ readonly row: Schema.$Record<Schema.String, Schema.Boolean>;
168
+ readonly reasons: Schema.$Record<Schema.String, Schema.String>;
169
+ readonly members: Schema.$Record<Schema.String, Schema.Boolean>;
170
+ readonly relations: Schema.$Record<Schema.String, Schema.Struct<{
171
+ readonly Link: Schema.Boolean;
172
+ readonly Unlink: Schema.Boolean;
173
+ }>>;
174
+ }>, {
175
+ readonly _tag: "Supplied";
176
+ readonly predict: Option.Option<Predict>;
177
+ readonly forbids: Option.Option<Forbids>;
178
+ }>;
102
179
  }> : never;
103
180
  /**
104
181
  * Whether the row's rule for `interaction` let the principal, when it was
@@ -285,6 +362,13 @@ interface Policy<User, R = never> {
285
362
  readonly linkable: (entity: AnyEntity, principal: Option.Option<User>, relation: string, interaction: 'Link' | 'Unlink') => Effect.Effect<Option.Option<RowRule>, never, R>;
286
363
  /** The principal's fields as row guards' inputs; a visitor has none. */
287
364
  readonly inputOf: (principal: Option.Option<User>) => Readonly<Record<string, unknown>>;
365
+ /**
366
+ * Who the principal is as a row: `declare`'s `viewer` Entity, by `key`.
367
+ * What a rule's `Expr.viewer` reads, and the server's viewer:
368
+ * `RemoteServer.make({ viewer: Policy.viewer })`. None for a visitor, and
369
+ * for a set that names no `viewer`.
370
+ */
371
+ readonly viewer: (principal: Option.Option<User>) => Option.Option<EntityRef>;
288
372
  /**
289
373
  * Who the principal is: `declare`'s `key`, the same function as `G.key`,
290
374
  * here for a server seam that holds the Policy and not the set. Not
@@ -326,9 +410,20 @@ interface Policy<User, R = never> {
326
410
  interface Builders<User> {
327
411
  /** A guard decided from the principal alone, by a body only the server has. */
328
412
  readonly principal: () => PrincipalSpec;
329
- /** A guard over `entity`'s rows: a predicate with the principal's fields as inputs. */
330
- readonly row: <E extends AnyEntity>(entity: E, body: (principal: Placeholders<User>) => Predicate) => RowSpec<E>;
413
+ /**
414
+ * A guard over `entity`'s rows: a predicate with the principal's fields as
415
+ * inputs. A predicate reading another Entity's fields is refused where it
416
+ * is written; one typed plain `Predicate` is checked when the set is
417
+ * declared.
418
+ */
419
+ readonly row: <E extends AnyEntity, P extends RuleOver<P, E['name']>>(entity: E, body: (principal: Placeholders<User>) => P) => RowSpec<E>;
331
420
  }
421
+ /**
422
+ * What a rule over the Entity `Name` may be: a predicate reading `Name`'s
423
+ * fields and relations, inputs and the viewer, or one whose reads are unknown
424
+ * to the type (a plain `Predicate`).
425
+ */
426
+ type RuleOver<P, Name extends string> = string extends ReadsOf<P> ? Predicate : [ReadsOf<P>] extends [Name] ? Predicate : Predicate & Invalid<`foldkit-guard: a rule over ${Name} reads ${Exclude<ReadsOf<P>, Name>}`>;
332
427
  declare const Guards: {
333
428
  /**
334
429
  * Adds the `may` member, the server's answer to what a principal may do
@@ -337,7 +432,23 @@ declare const Guards: {
337
432
  */
338
433
  may: <E extends AnyEntity>(entity: E & ("may" & keyof E["members"] extends never ? unknown : {
339
434
  readonly alreadyAMember: "may" & keyof E["members"];
340
- })) => E extends import("foldkit-entity").Entity<infer Name extends string, infer Fields extends Schema.Struct.Fields, infer R extends Readonly<Record<string, import("foldkit-entity").RelationSpec<AnyEntity, import("foldkit-entity").Cardinality, boolean>>>, infer D extends Readonly<Record<string, import("foldkit-entity").DerivedSpec<Schema.Constraint>>>> ? import("foldkit-entity").Entity<Name, Fields, R, D & {
435
+ })) => E extends import("foldkit-entity").VariantEntity<infer Name extends string, infer Fields extends Schema.Struct.Fields, infer R extends Readonly<Record<string, import("foldkit-entity").RelationSpec<AnyEntity, import("foldkit-entity").Cardinality, boolean>>>, infer D extends Readonly<Record<string, import("foldkit-entity").DerivedSpec<Schema.Constraint, {
436
+ readonly _tag: "Count";
437
+ readonly relation: import("foldkit-entity").EntityRelation<string, string, AnyEntity, "one", boolean>;
438
+ } | {
439
+ readonly _tag: "Exists";
440
+ readonly relation: import("foldkit-entity").EntityRelation<string, string, AnyEntity, "one", boolean>;
441
+ readonly viewer: import("foldkit-entity").EntityRelation<string, string, AnyEntity, "one", boolean>;
442
+ } | {
443
+ readonly _tag: "Supplied";
444
+ readonly predict: Option.Option<import("foldkit-entity").Predict>;
445
+ readonly forbids: Option.Option<import("foldkit-entity").Forbids>;
446
+ }>>>, infer U extends Schema.Top & {
447
+ readonly tag: '_tag';
448
+ readonly cases: Readonly<Record<string, {
449
+ readonly fields: Schema.Struct.Fields;
450
+ }>>;
451
+ }> ? import("foldkit-entity").VariantEntity<Name, Fields, R, D & {
341
452
  readonly may: import("foldkit-entity").DerivedSpec<Schema.Struct<{
342
453
  readonly row: Schema.$Record<Schema.String, Schema.Boolean>;
343
454
  readonly reasons: Schema.$Record<Schema.String, Schema.String>;
@@ -346,7 +457,36 @@ declare const Guards: {
346
457
  readonly Link: Schema.Boolean;
347
458
  readonly Unlink: Schema.Boolean;
348
459
  }>>;
349
- }>>;
460
+ }>, {
461
+ readonly _tag: "Supplied";
462
+ readonly predict: Option.Option<import("foldkit-entity").Predict>;
463
+ readonly forbids: Option.Option<import("foldkit-entity").Forbids>;
464
+ }>;
465
+ }, U> : E extends import("foldkit-entity").Entity<infer Name_1 extends string, infer Fields_1 extends Schema.Struct.Fields, infer R_1 extends Readonly<Record<string, import("foldkit-entity").RelationSpec<AnyEntity, import("foldkit-entity").Cardinality, boolean>>>, infer D_1 extends Readonly<Record<string, import("foldkit-entity").DerivedSpec<Schema.Constraint, {
466
+ readonly _tag: "Count";
467
+ readonly relation: import("foldkit-entity").EntityRelation<string, string, AnyEntity, "one", boolean>;
468
+ } | {
469
+ readonly _tag: "Exists";
470
+ readonly relation: import("foldkit-entity").EntityRelation<string, string, AnyEntity, "one", boolean>;
471
+ readonly viewer: import("foldkit-entity").EntityRelation<string, string, AnyEntity, "one", boolean>;
472
+ } | {
473
+ readonly _tag: "Supplied";
474
+ readonly predict: Option.Option<import("foldkit-entity").Predict>;
475
+ readonly forbids: Option.Option<import("foldkit-entity").Forbids>;
476
+ }>>>> ? import("foldkit-entity").Entity<Name_1, Fields_1, R_1, D_1 & {
477
+ readonly may: import("foldkit-entity").DerivedSpec<Schema.Struct<{
478
+ readonly row: Schema.$Record<Schema.String, Schema.Boolean>;
479
+ readonly reasons: Schema.$Record<Schema.String, Schema.String>;
480
+ readonly members: Schema.$Record<Schema.String, Schema.Boolean>;
481
+ readonly relations: Schema.$Record<Schema.String, Schema.Struct<{
482
+ readonly Link: Schema.Boolean;
483
+ readonly Unlink: Schema.Boolean;
484
+ }>>;
485
+ }>, {
486
+ readonly _tag: "Supplied";
487
+ readonly predict: Option.Option<import("foldkit-entity").Predict>;
488
+ readonly forbids: Option.Option<import("foldkit-entity").Forbids>;
489
+ }>;
350
490
  }> : never;
351
491
  /**
352
492
  * `Me`, the visitor as an Entity: one row, `me`, that everyone reads and no
@@ -379,6 +519,12 @@ declare const Guards: {
379
519
  * a decision written down; `Guards.matrix` prints it `closed` or `open`.
380
520
  */
381
521
  readonly unguarded: 'allow' | 'deny';
522
+ /**
523
+ * The Entity whose row each principal is, by `key`: what a row guard's
524
+ * `Expr.viewer` of it reads, on the server and the client alike. A set
525
+ * without one refuses a rule that reads the viewer.
526
+ */
527
+ readonly viewer?: AnyEntity | undefined;
382
528
  }) => GuardSet<Name, Schema.Struct.Type<Fields>, S>;
383
529
  attach: <Name extends string, User, E extends AnyEntity>(G: {
384
530
  readonly name: Name;
@@ -511,4 +657,4 @@ interface Attachment {
511
657
  }
512
658
  declare const attached: (entity: AnyEntity) => Option.Option<Attachment>;
513
659
  export { May as A, PrincipalGuard as C, RowSpec as D, RowGuard as E, RowRule as F, MaySchema as M, Condition as N, ME as O, MemberRead as P, Policy as S, PrincipalSpec as T, Builders as _, Deny as a, Guards as b, Interaction as c, Redact as d, RuleFor as f, Body as g, AnyGuard as h, Attachment as i, MayAnswer as j, MeEntity as k, InteractionKey as l, About as m, AnyRule as n, Explain as o, Surface as p, Attach as r, Inherit as s, All as t, On as u, Decision as v, PrincipalOf as w, Placeholders as x, GuardSet as y };
514
- //# sourceMappingURL=attach-BepaL930.d.mts.map
660
+ //# sourceMappingURL=attach-CJl-GtbN.d.mts.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"attach-CJl-GtbN.d.mts","names":["MemberKeys","_$__attach_js0.Attach","_$__attach_js0.AnyRule","_$__attach_js0.Inherit","_$__attach_js0.All","_$__attach_js0.Redact","_$__attach_js0.Explain","_$__attach_js0.On"],"sources":["../src/condition.ts","../src/may.ts","../src/me.ts","../src/index.ts","../src/attach.ts"],"mappings":"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"}
@@ -1,6 +1,6 @@
1
- import { a as defaultDeny, d as surfaceOf, r as attached } from "./attach-CRCF5XHS.mjs";
1
+ import { a as defaultDeny, d as surfaceOf, r as attached } from "./attach-CEGlbWu5.mjs";
2
2
  import { Effect, Match, Option } from "effect";
3
- import { Query, evaluateEach } from "foldkit-entity";
3
+ import { Held, Judge, Query, evaluateEach, viewerIdOf } from "foldkit-entity";
4
4
  // src/condition.ts
5
5
  /**
6
6
  * What an attachment's read rules come to for one principal, once its
@@ -8,6 +8,8 @@ import { Query, evaluateEach } from "foldkit-entity";
8
8
  * interpreter runs (`evaluate` in memory, SQL in a binding). Principal guards
9
9
  * never reach it, so their bodies stay on the server that decided them.
10
10
  */
11
+ /** Whether a row guard reads another row: one row cannot judge it. */
12
+ const reachesOther = (guard) => Query.dependencies(guard.query).reaches.length > 0;
11
13
  const always = Object.freeze({ _tag: "Always" });
12
14
  const never = Object.freeze({ _tag: "Never" });
13
15
  /** A conjunction, with what it settles already folded away. */
@@ -57,7 +59,10 @@ const Condition = {
57
59
  const holds = (each) => Match.valueTags(each, {
58
60
  Always: () => true,
59
61
  Never: () => false,
60
- Row: ({ guard }) => evaluateEach(guard.query, input, [values], { operators }).matched.length === 1,
62
+ Row: ({ guard, context }) => evaluateEach(guard.query, input, [Held.fromRefs(guard.query, values)], {
63
+ operators,
64
+ context
65
+ }).matched.length === 1,
61
66
  Inherit: ({ relation }) => inherit(relation),
62
67
  And: ({ conditions }) => conditions.every(holds),
63
68
  Or: ({ conditions }) => conditions.some(holds)
@@ -65,6 +70,88 @@ const Condition = {
65
70
  return holds(condition);
66
71
  },
67
72
  /**
73
+ * `condition` decided over one row as far as one row can: each row guard
74
+ * over the row alone judged (`holds`), an inherited Read refused, as a
75
+ * writer refuses one, and each row guard that reads another row (a path, an
76
+ * exists) kept for a statement to judge. `Always` or `Never` when the row
77
+ * alone decides it.
78
+ */
79
+ residual: (condition, values, input, operators) => {
80
+ const decided = (each) => Match.valueTags(each, {
81
+ Always: () => each,
82
+ Never: () => each,
83
+ Row: (row) => reachesOther(row.guard) ? each : Condition.holds(each, values, input, () => false, operators) ? always : never,
84
+ Inherit: () => never,
85
+ And: ({ conditions }) => and(conditions.map(decided)),
86
+ Or: ({ conditions }) => or(conditions.map(decided))
87
+ });
88
+ return decided(condition);
89
+ },
90
+ /** `Always` and `Never` as what one row decided; none where a statement must judge the rest. */
91
+ decided: (condition) => Match.valueTags(condition, {
92
+ Always: () => Option.some(true),
93
+ Never: () => Option.some(false),
94
+ Row: () => Option.none(),
95
+ Inherit: () => Option.none(),
96
+ And: () => Option.none(),
97
+ Or: () => Option.none()
98
+ }),
99
+ /**
100
+ * The members of `written`, the row a write changes, that a condition's
101
+ * guards reading another row start from: each one's fields, the relation
102
+ * each path leaves by, and, where `written` is the viewer's own row, what a
103
+ * path from the viewer leaves it by. A write that changes one would need the
104
+ * guard judged over the row it leaves, which a statement over the stored row
105
+ * does not do.
106
+ */
107
+ reachedFrom: (condition, written) => {
108
+ const read = (each) => Match.valueTags(each, {
109
+ Always: () => [],
110
+ Never: () => [],
111
+ Row: ({ guard, context }) => {
112
+ if (!reachesOther(guard)) return [];
113
+ const dependencies = Query.dependencies(guard.query);
114
+ return [...dependencies.predicate.map((field) => field.key), ...dependencies.reaches.flatMap((reach) => Match.valueTags(reach, {
115
+ Path: ({ via }) => [via[0].key],
116
+ Exists: ({ via }) => via.slice(0, 1).map((relation) => relation.key),
117
+ ViewerPath: ({ viewer, via, field }) => {
118
+ const start = viewer.target();
119
+ return start.name === written.entity && Option.exists(viewerIdOf(start, context), (id) => id === written.id) ? [via[0]?.key ?? field.key] : [];
120
+ }
121
+ }))];
122
+ },
123
+ Inherit: () => [],
124
+ And: ({ conditions }) => conditions.flatMap(read),
125
+ Or: ({ conditions }) => conditions.flatMap(read)
126
+ });
127
+ return [...new Set(read(condition))];
128
+ },
129
+ /**
130
+ * Whether a row a client holds meets `condition`, a part it cannot decide
131
+ * taken to be `assumed`: a row guard over the principal's fields, which a
132
+ * client is not given, an inherited Read, and a rule over a row or field
133
+ * the holder lacks. A row guard reads the holder's rows (`rows`) where it
134
+ * follows a path from the viewer. Run once assuming each way, it is decided
135
+ * where both agree, since no part of a condition is negated.
136
+ */
137
+ judge: (condition, row, rows, assumed) => {
138
+ const judge = (each) => Match.valueTags(each, {
139
+ Always: () => true,
140
+ Never: () => false,
141
+ Row: ({ guard, context }) => readsPrincipal(guard) ? assumed : Judge.match(Judge.predicate(guard.body, row, {
142
+ context,
143
+ rows
144
+ }), {
145
+ onKnown: (truth) => truth === true,
146
+ onUnknown: () => assumed
147
+ }),
148
+ Inherit: () => assumed,
149
+ And: ({ conditions }) => conditions.every(judge),
150
+ Or: ({ conditions }) => conditions.some(judge)
151
+ });
152
+ return judge(condition);
153
+ },
154
+ /**
68
155
  * `condition` with every row guard that reads one of `unset`, and every
69
156
  * relation of them it follows, refused: a field a create leaves unset
70
157
  * matches no guard, `isNull` and `isNotNull` alike, since the create never
@@ -117,13 +204,14 @@ const principalGuardsIn = (rules) => {
117
204
  * decided once, however many rules name it; a visitor passes no row guard
118
205
  * that reads the principal.
119
206
  */
120
- const conditionsFor = (rules, decide, visitor) => Effect.map(Effect.forEach(principalGuardsIn(rules), (guard) => Effect.map(decide(guard), (allowed) => [guard.name, allowed])), (decisions) => {
207
+ const conditionsFor = (rules, decide, visitor, context) => Effect.map(Effect.forEach(principalGuardsIn(rules), (guard) => Effect.map(decide(guard), (allowed) => [guard.name, allowed])), (decisions) => {
121
208
  const allowed = new Map(decisions);
122
209
  const conditionOf = (rule) => Match.valueTags(rule, {
123
210
  PrincipalGuard: ({ name }) => allowed.get(name) === true ? always : never,
124
211
  RowGuard: (guard) => visitor && readsPrincipal(guard) ? never : Object.freeze({
125
212
  _tag: "Row",
126
- guard
213
+ guard,
214
+ context
127
215
  }),
128
216
  All: ({ rules }) => and(rules.map(conditionOf)),
129
217
  Inherit: ({ relation }) => Object.freeze({
@@ -137,7 +225,7 @@ const conditionsFor = (rules, decide, visitor) => Effect.map(Effect.forEach(prin
137
225
  * How a Policy decides one interaction, given the set's principal guards as
138
226
  * decided for it.
139
227
  */
140
- const deciding = (decide, visitor, interaction) => ({
228
+ const deciding = (decide, visitor, interaction, context) => ({
141
229
  /** Who may do it to which rows of `entity`: `always`, then the row's rules for it. */
142
230
  row: (entity) => Option.match(attached(entity), {
143
231
  onNone: () => Effect.succeed({
@@ -152,7 +240,7 @@ const deciding = (decide, visitor, interaction) => ({
152
240
  onSome: ({ rules }) => rules
153
241
  });
154
242
  const unguarded = attachment.unguarded === "allow" ? always : never;
155
- return Effect.map(conditionsFor([...attachment.always, ...rules], decide, visitor), (condition) => ({
243
+ return Effect.map(conditionsFor([...attachment.always, ...rules], decide, visitor, context), (condition) => ({
156
244
  condition: and([condition(attachment.always, and), Option.isSome(row) ? condition(rules, or) : unguarded]),
157
245
  deny: Option.getOrElse(Option.flatMap(row, ({ deny }) => deny), () => defaultDeny(target))
158
246
  }));
@@ -185,7 +273,7 @@ const deciding = (decide, visitor, interaction) => ({
185
273
  }]
186
274
  });
187
275
  });
188
- return Effect.map(conditionsFor(surfaces.flatMap(({ rules }) => rules), decide, visitor), (condition) => surfaces.map(({ member, rules, deny }) => ({
276
+ return Effect.map(conditionsFor(surfaces.flatMap(({ rules }) => rules), decide, visitor, context), (condition) => surfaces.map(({ member, rules, deny }) => ({
189
277
  member,
190
278
  condition: condition(rules, or),
191
279
  deny
@@ -201,7 +289,7 @@ const deciding = (decide, visitor, interaction) => ({
201
289
  };
202
290
  return Option.match(Option.flatMap(attached(entity), (attachment) => surfaceOf(attachment, target)), {
203
291
  onNone: () => Effect.succeed(Option.none()),
204
- onSome: ({ rules, deny }) => Effect.map(conditionsFor(rules, decide, visitor), (condition) => Option.some({
292
+ onSome: ({ rules, deny }) => Effect.map(conditionsFor(rules, decide, visitor, context), (condition) => Option.some({
205
293
  condition: condition(rules, or),
206
294
  deny: Option.getOrElse(deny, () => defaultDeny(target))
207
295
  }))
@@ -214,4 +302,4 @@ const rowTarget = (interaction) => ({
214
302
  });
215
303
  export { deciding as n, readsPrincipal as r, Condition as t };
216
304
 
217
- //# sourceMappingURL=condition-Dx54lL7v.mjs.map
305
+ //# sourceMappingURL=condition-dNSbUHzE.mjs.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"condition-dNSbUHzE.mjs","names":[],"sources":["../src/condition.ts"],"sourcesContent":["/**\n * What an attachment's read rules come to for one principal, once its\n * principal guards are decided: a condition over the row, which an\n * interpreter runs (`evaluate` in memory, SQL in a binding). Principal guards\n * never reach it, so their bodies stay on the server that decided them.\n */\nimport { Effect, Match, Option } from 'effect'\nimport {\n Held,\n Judge,\n Query,\n evaluateEach,\n viewerIdOf,\n type AnyEntity,\n type EntityRef,\n type ExprContext,\n type HeldRow,\n type HeldRows,\n type MemoryOperators,\n} from 'foldkit-entity'\nimport { attached, defaultDeny, surfaceOf, type AnyRule, type Deny } from './attach.js'\nimport type { PrincipalGuard, RowGuard } from './index.js'\n\nexport type Condition =\n | { readonly _tag: 'Always' }\n | { readonly _tag: 'Never' }\n /** A row guard, and what its `Expr.viewer` reads: the principal it was decided for. */\n | {\n readonly _tag: 'Row'\n readonly guard: RowGuard<any, AnyEntity>\n readonly context: ExprContext\n }\n /** The row its `one` relation points at is readable. */\n | { readonly _tag: 'Inherit'; readonly relation: string }\n | { readonly _tag: 'And'; readonly conditions: ReadonlyArray<Condition> }\n | { readonly _tag: 'Or'; readonly conditions: ReadonlyArray<Condition> }\n\n/** Whether a row guard reads another row: one row cannot judge it. */\nconst reachesOther = (guard: RowGuard<any, AnyEntity>): boolean =>\n Query.dependencies(guard.query).reaches.length > 0\n\nconst always: Condition = Object.freeze({ _tag: 'Always' })\nconst never: Condition = Object.freeze({ _tag: 'Never' })\n\n/** A conjunction, with what it settles already folded away. */\nconst and = (conditions: ReadonlyArray<Condition>): Condition => {\n const kept: Array<Condition> = []\n for (const condition of conditions) {\n if (condition._tag === 'Never') return never\n if (condition._tag !== 'Always') kept.push(condition)\n }\n if (kept.length === 0) return always\n if (kept.length === 1) return kept[0]!\n return Object.freeze({ _tag: 'And', conditions: Object.freeze(kept) })\n}\n\n/** A disjunction, with what it settles already folded away. */\nconst or = (conditions: ReadonlyArray<Condition>): Condition => {\n const kept: Array<Condition> = []\n for (const condition of conditions) {\n if (condition._tag === 'Always') return always\n if (condition._tag !== 'Never') kept.push(condition)\n }\n if (kept.length === 0) return never\n if (kept.length === 1) return kept[0]!\n return Object.freeze({ _tag: 'Or', conditions: Object.freeze(kept) })\n}\n\nexport const Condition = {\n always,\n never,\n and,\n or,\n\n /**\n * Whether a row's stored values meet `condition`, its row guards read with\n * `input` (the principal's, from `G.inputOf`). `inherit` answers whether the\n * row a relation points at is readable, which only the caller can look up.\n * `operators` runs the guards' primitive operators: the policy's.\n *\n * A row guard the row's own values make an operator refuse (text holding a\n * NUL, an implementation that throws) does not hold: what a write supplies\n * can deny it, never end the request.\n */\n holds: (\n condition: Condition,\n values: Readonly<Record<string, unknown>>,\n input: Readonly<Record<string, unknown>>,\n inherit: (relation: string) => boolean,\n operators: MemoryOperators,\n ): boolean => {\n const holds = (each: Condition): boolean =>\n Match.valueTags(each, {\n Always: () => true,\n Never: () => false,\n // A row as a Source reads it holds its links as ref keys; the rule reads ids.\n Row: ({ guard, context }) =>\n evaluateEach(guard.query, input, [Held.fromRefs(guard.query, values)], {\n operators,\n context,\n }).matched.length === 1,\n Inherit: ({ relation }) => inherit(relation),\n And: ({ conditions }) => conditions.every(holds),\n Or: ({ conditions }) => conditions.some(holds),\n })\n return holds(condition)\n },\n\n /**\n * `condition` decided over one row as far as one row can: each row guard\n * over the row alone judged (`holds`), an inherited Read refused, as a\n * writer refuses one, and each row guard that reads another row (a path, an\n * exists) kept for a statement to judge. `Always` or `Never` when the row\n * alone decides it.\n */\n residual: (\n condition: Condition,\n values: Readonly<Record<string, unknown>>,\n input: Readonly<Record<string, unknown>>,\n operators: MemoryOperators,\n ): Condition => {\n const decided = (each: Condition): Condition =>\n Match.valueTags(each, {\n Always: () => each,\n Never: () => each,\n Row: row =>\n reachesOther(row.guard)\n ? each\n : Condition.holds(each, values, input, () => false, operators)\n ? always\n : never,\n Inherit: () => never,\n And: ({ conditions }) => and(conditions.map(decided)),\n Or: ({ conditions }) => or(conditions.map(decided)),\n })\n return decided(condition)\n },\n\n /** `Always` and `Never` as what one row decided; none where a statement must judge the rest. */\n decided: (condition: Condition): Option.Option<boolean> =>\n Match.valueTags(condition, {\n Always: () => Option.some(true),\n Never: () => Option.some(false),\n Row: () => Option.none(),\n Inherit: () => Option.none(),\n And: () => Option.none(),\n Or: () => Option.none(),\n }),\n\n /**\n * The members of `written`, the row a write changes, that a condition's\n * guards reading another row start from: each one's fields, the relation\n * each path leaves by, and, where `written` is the viewer's own row, what a\n * path from the viewer leaves it by. A write that changes one would need the\n * guard judged over the row it leaves, which a statement over the stored row\n * does not do.\n */\n reachedFrom: (condition: Condition, written: EntityRef): ReadonlyArray<string> => {\n const read = (each: Condition): ReadonlyArray<string> =>\n Match.valueTags(each, {\n Always: () => [],\n Never: () => [],\n Row: ({ guard, context }) => {\n if (!reachesOther(guard)) return []\n const dependencies = Query.dependencies(guard.query)\n return [\n ...dependencies.predicate.map(field => field.key),\n // An exists reached through a path leaves by its first relation as surely\n // as a path does; one over the row itself reads only its id. A path from the\n // viewer leaves the row written the same way when that row is the viewer's.\n ...dependencies.reaches.flatMap(reach =>\n Match.valueTags(reach, {\n Path: ({ via }) => [via[0]!.key],\n Exists: ({ via }) => via.slice(0, 1).map(relation => relation.key),\n ViewerPath: ({ viewer, via, field }) => {\n const start = viewer.target()\n return start.name === written.entity &&\n Option.exists(viewerIdOf(start, context), id => id === written.id)\n ? [via[0]?.key ?? field.key]\n : []\n },\n }),\n ),\n ]\n },\n Inherit: () => [],\n And: ({ conditions }) => conditions.flatMap(read),\n Or: ({ conditions }) => conditions.flatMap(read),\n })\n return [...new Set(read(condition))]\n },\n\n /**\n * Whether a row a client holds meets `condition`, a part it cannot decide\n * taken to be `assumed`: a row guard over the principal's fields, which a\n * client is not given, an inherited Read, and a rule over a row or field\n * the holder lacks. A row guard reads the holder's rows (`rows`) where it\n * follows a path from the viewer. Run once assuming each way, it is decided\n * where both agree, since no part of a condition is negated.\n */\n judge: (condition: Condition, row: HeldRow, rows: HeldRows, assumed: boolean): boolean => {\n const judge = (each: Condition): boolean =>\n Match.valueTags(each, {\n Always: () => true,\n Never: () => false,\n Row: ({ guard, context }) =>\n readsPrincipal(guard)\n ? assumed\n : Judge.match(Judge.predicate(guard.body, row, { context, rows }), {\n // SQL's null leaves a row out, as false does.\n onKnown: truth => truth === true,\n onUnknown: () => assumed,\n }),\n Inherit: () => assumed,\n And: ({ conditions }) => conditions.every(judge),\n Or: ({ conditions }) => conditions.some(judge),\n })\n return judge(condition)\n },\n\n /**\n * `condition` with every row guard that reads one of `unset`, and every\n * relation of them it follows, refused: a field a create leaves unset\n * matches no guard, `isNull` and `isNotNull` alike, since the create never\n * said what it holds.\n */\n unsetting: (condition: Condition, unset: ReadonlySet<string>): Condition => {\n const kept = (each: Condition): Condition =>\n Match.valueTags(each, {\n Always: () => each,\n Never: () => each,\n Row: ({ guard }) =>\n Query.dependencies(guard.query).predicate.some(field => unset.has(field.key))\n ? never\n : each,\n Inherit: ({ relation }) => (unset.has(relation) ? never : each),\n And: ({ conditions }) => and(conditions.map(kept)),\n Or: ({ conditions }) => or(conditions.map(kept)),\n })\n return kept(condition)\n },\n\n /** The members a condition reads: its row guards' fields, and each relation it follows. */\n members: (condition: Condition): ReadonlyArray<string> => {\n const read = (each: Condition): ReadonlyArray<string> =>\n Match.valueTags(each, {\n Always: () => [],\n Never: () => [],\n Row: ({ guard }) => Query.dependencies(guard.query).predicate.map(field => field.key),\n Inherit: ({ relation }) => [relation],\n And: ({ conditions }) => conditions.flatMap(read),\n Or: ({ conditions }) => conditions.flatMap(read),\n })\n return [...new Set(read(condition))]\n },\n}\n\n/** A member's read rule for one principal: the condition, and what a refusal shows. */\nexport interface MemberRead {\n readonly member: string\n readonly condition: Condition\n readonly deny: Deny\n}\n\n/**\n * Whether a row guard reads the principal's fields. A visitor has none, so\n * passes no guard that does; one over the row alone (`publishedAt` is set)\n * holds for a visitor as for anyone.\n */\nexport const readsPrincipal = (guard: RowGuard<any, AnyEntity>): boolean =>\n Query.dependencies(guard.query).inputs.length > 0\n\n/** Every principal guard the rules name, each once. */\nconst principalGuardsIn = (rules: ReadonlyArray<AnyRule>): ReadonlyArray<PrincipalGuard<any>> => {\n const found = new Map<string, PrincipalGuard<any>>()\n const visit = (rule: AnyRule): void =>\n Match.valueTags(rule, {\n PrincipalGuard: guard => void found.set(guard.name, guard),\n RowGuard: () => {},\n All: ({ rules }) => rules.forEach(visit),\n Inherit: () => {},\n })\n rules.forEach(visit)\n return [...found.values()]\n}\n\n/**\n * Turns `rules` into a condition for one principal. Each principal guard is\n * decided once, however many rules name it; a visitor passes no row guard\n * that reads the principal.\n */\nconst conditionsFor = <R>(\n rules: ReadonlyArray<AnyRule>,\n decide: (guard: PrincipalGuard<any>) => Effect.Effect<boolean, never, R>,\n visitor: boolean,\n context: ExprContext,\n): Effect.Effect<(rules: ReadonlyArray<AnyRule>, join: typeof and) => Condition, never, R> =>\n Effect.map(\n Effect.forEach(principalGuardsIn(rules), guard =>\n Effect.map(decide(guard), allowed => [guard.name, allowed] as const),\n ),\n decisions => {\n const allowed = new Map(decisions)\n const conditionOf = (rule: AnyRule): Condition =>\n Match.valueTags(rule, {\n PrincipalGuard: ({ name }) => (allowed.get(name) === true ? always : never),\n RowGuard: guard =>\n visitor && readsPrincipal(guard)\n ? never\n : Object.freeze({ _tag: 'Row' as const, guard, context }),\n All: ({ rules }) => and(rules.map(conditionOf)),\n Inherit: ({ relation }) => Object.freeze({ _tag: 'Inherit' as const, relation }),\n })\n return (rules, join) => join(rules.map(conditionOf))\n },\n )\n\n/** A row's rule for one interaction and principal: the condition, and what a refusal shows. */\nexport interface RowRule {\n readonly condition: Condition\n readonly deny: Deny\n}\n\n/**\n * How a Policy decides one interaction, given the set's principal guards as\n * decided for it.\n */\nexport const deciding = <R>(\n decide: (guard: PrincipalGuard<any>) => Effect.Effect<boolean, never, R>,\n visitor: boolean,\n interaction: string,\n context: ExprContext,\n) => ({\n /** Who may do it to which rows of `entity`: `always`, then the row's rules for it. */\n row: (entity: AnyEntity): Effect.Effect<RowRule, never, R> =>\n Option.match(attached(entity), {\n onNone: () =>\n Effect.succeed({ condition: always, deny: defaultDeny(rowTarget(interaction)) }),\n onSome: attachment => {\n const target = rowTarget(interaction)\n const row = surfaceOf(attachment, target)\n const rules = Option.match(row, {\n onNone: (): ReadonlyArray<AnyRule> => [],\n onSome: ({ rules }) => rules,\n })\n // An interaction left without rules falls to the set's default.\n const unguarded = attachment.unguarded === 'allow' ? always : never\n return Effect.map(\n conditionsFor([...attachment.always, ...rules], decide, visitor, context),\n condition => ({\n condition: and([\n condition(attachment.always, and),\n Option.isSome(row) ? condition(rules, or) : unguarded,\n ]),\n deny: Option.getOrElse(\n Option.flatMap(row, ({ deny }) => deny),\n () => defaultDeny(target),\n ),\n }),\n )\n },\n }),\n\n /**\n * The rule of each of `members` that has one for this interaction. One\n * without follows its row. A relation key's Read is its relation's, decided\n * over the parent row as a member's is.\n */\n members: (\n entity: AnyEntity,\n members: ReadonlyArray<string>,\n ): Effect.Effect<ReadonlyArray<MemberRead>, never, R> =>\n Option.match(attached(entity), {\n onNone: () => Effect.succeed([]),\n onSome: attachment => {\n const surfaces = members.flatMap(member => {\n const target = Object.hasOwn(entity.relations, member)\n ? ({ _tag: 'Relation', relation: member, interaction } as const)\n : ({ _tag: 'Member', member, interaction } as const)\n return Option.match(surfaceOf(attachment, target), {\n onNone: () => [],\n onSome: ({ rules, deny }) => [\n { member, rules, deny: Option.getOrElse(deny, () => defaultDeny(target)) },\n ],\n })\n })\n return Effect.map(\n conditionsFor(\n surfaces.flatMap(({ rules }) => rules),\n decide,\n visitor,\n context,\n ),\n condition =>\n surfaces.map(({ member, rules, deny }) => ({\n member,\n condition: condition(rules, or),\n deny,\n })),\n )\n },\n }),\n\n /** A relation's rule for this interaction (`Link`, `Unlink`), when it has one. */\n relation: (\n entity: AnyEntity,\n relation: string,\n ): Effect.Effect<Option.Option<RowRule>, never, R> => {\n const target = { _tag: 'Relation', relation, interaction } as const\n return Option.match(\n Option.flatMap(attached(entity), attachment => surfaceOf(attachment, target)),\n {\n onNone: () => Effect.succeed(Option.none()),\n onSome: ({ rules, deny }) =>\n Effect.map(conditionsFor(rules, decide, visitor, context), condition =>\n Option.some({\n condition: condition(rules, or),\n deny: Option.getOrElse(deny, () => defaultDeny(target)),\n }),\n ),\n },\n )\n },\n})\n\nconst rowTarget = (interaction: string) => ({ _tag: 'Row', interaction }) as const\n"],"mappings":"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"}
@@ -1,4 +1,4 @@
1
- import { S as Policy } from "./attach-BepaL930.mjs";
1
+ import { S as Policy } from "./attach-CJl-GtbN.mjs";
2
2
  import { AnyEntity } from "foldkit-entity";
3
3
  import { DrizzleOperators, Visible } from "foldkit-remote-drizzle";
4
4
  export declare const GuardDrizzle: {
package/dist/drizzle.mjs CHANGED
@@ -1,10 +1,10 @@
1
- import { o as flattenRules, r as attached } from "./attach-CRCF5XHS.mjs";
2
- import { n as rowRules } from "./placed-BvdNmZJu.mjs";
1
+ import { o as flattenRules, r as attached } from "./attach-CEGlbWu5.mjs";
2
+ import { n as rowRules } from "./placed-CGyo-NRR.mjs";
3
3
  import { Effect, Match, Option } from "effect";
4
4
  import { Query } from "foldkit-entity";
5
5
  import { RemoteServerError } from "foldkit-remote-server";
6
6
  import { and, or, sql } from "drizzle-orm";
7
- import { DrizzleOperators, compileWhere, idColumn, supported as supported$1 } from "foldkit-remote-drizzle";
7
+ import { DrizzleOperators, bodyOperations, compileWhere, idColumn } from "foldkit-remote-drizzle";
8
8
  // src/drizzle.ts
9
9
  /**
10
10
  * A guard set's read rules as `foldkit-remote-drizzle` bindings' `visible`:
@@ -46,7 +46,7 @@ visible: (policy, entities, options = {}) => {
46
46
  for (const rule of flattenRules(readRules(entity))) Match.valueTags(rule, {
47
47
  PrincipalGuard: () => {},
48
48
  RowGuard: (guard) => {
49
- const missing = Query.unsupported(guard.query, supported$1, sqlOperators);
49
+ const missing = Query.unsupported(guard.query, bodyOperations, sqlOperators);
50
50
  if (missing.length > 0) fail(`${entity.name}'s ${guard.name} needs ${missing.join(", ")}, which SQL here does not run`);
51
51
  },
52
52
  All: () => {},
@@ -69,12 +69,14 @@ visible: (policy, entities, options = {}) => {
69
69
  const of = (condition) => Match.valueTags(condition, {
70
70
  Always: () => void 0,
71
71
  Never: () => nothing,
72
- Row: ({ guard }) => and(...compileWhere(guard.query, {
72
+ Row: ({ guard, context }) => and(...compileWhere(guard.query, {
73
73
  ...binding,
74
74
  operators: {
75
75
  memory: policy.operators,
76
76
  sql: sqlOperators
77
- }
77
+ },
78
+ context,
79
+ visibleOf: () => Option.none()
78
80
  }, input, `${name}.${guard.name}`)),
79
81
  And: ({ conditions: parts }) => and(...parts.map(of)),
80
82
  Or: ({ conditions: parts }) => or(...parts.map(of)),
@@ -1 +1 @@
1
- {"version":3,"file":"drizzle.mjs","names":["supported"],"sources":["../src/drizzle.ts"],"sourcesContent":["/**\n * A guard set's read rules as `foldkit-remote-drizzle` bindings' `visible`:\n * each principal guard decided, what is left compiled to SQL over the table,\n * and an inherited Read a subquery over the related table's own rule.\n */\nimport { and, or, sql, type SQL } from 'drizzle-orm'\nimport { Effect, Match, Option } from 'effect'\nimport { Query, type AnyEntity } from 'foldkit-entity'\nimport {\n DrizzleOperators,\n compileWhere,\n idColumn,\n supported,\n type AnyEntityBinding,\n type Visible,\n} from 'foldkit-remote-drizzle'\nimport { RemoteServerError } from 'foldkit-remote-server'\nimport { attached, flattenRules, type AnyRule } from './attach.js'\nimport type { Condition } from './condition.js'\nimport type { Policy } from './index.js'\nimport { rowRules } from './placed.js'\n\n// A declaration, not an arrow, so a call narrows what follows it.\nfunction fail(message: string): never {\n throw new Error(`[foldkit-guard] GuardDrizzle.visible: ${message}`)\n}\n\n/** Every rule that decides who may read a row of `entity`. */\nconst readRules = (entity: AnyEntity): ReadonlyArray<AnyRule> =>\n Option.match(attached(entity), {\n onNone: () => [],\n onSome: attachment => [...attachment.always, ...(attachment.row['Read']?.rules ?? [])],\n })\n\nconst nothing = sql`1 = 0`\n\nexport const GuardDrizzle = {\n /**\n * The `visible` rule of each of `entities`, the Entities as `Guards.attach`\n * returned them, by name, for `bind`'s storage. Checked here, before any\n * request: a row guard this compiler cannot run, and an inherited Read whose\n * Entity is not listed, has no Read rule, or leads back to itself, throw.\n * `operators` is the SQL table each rule is checked against here and compiled\n * by (the kernel's when not given), and the policy's table decides what a rule\n * reads from the input alone, so a server that starts can compile every rule\n * whatever table its bindings were given. Give it the bindings' SQL table, so\n * a rule and a query over one operator compile it alike.\n *\n * ```ts\n * const visible = GuardDrizzle.visible(Policy, [Todo, Project])\n * bind(Domain, { Todo: { table: todos, visible: visible.Todo, … }, … })\n * ```\n */\n visible: <User, const Es extends ReadonlyArray<AnyEntity>>(\n policy: Policy<User>,\n entities: Es,\n options: { readonly operators?: DrizzleOperators | undefined } = {},\n ): { readonly [K in Es[number]['name']]: Visible } => {\n const sqlOperators = options.operators ?? DrizzleOperators.kernel\n const byName = new Map(entities.map(entity => [entity.name, entity] as const))\n const inherits = new Map<string, ReadonlyArray<string>>()\n for (const entity of entities) {\n const targets: Array<string> = []\n for (const rule of flattenRules(readRules(entity))) {\n Match.valueTags(rule, {\n PrincipalGuard: () => {},\n RowGuard: guard => {\n const missing = Query.unsupported(guard.query, supported, sqlOperators)\n if (missing.length > 0) {\n fail(\n `${entity.name}'s ${guard.name} needs ${missing.join(', ')}, which SQL here does not run`,\n )\n }\n },\n All: () => {},\n Inherit: ({ relation }) => {\n const target = entity.relations[relation]!.target().name\n const guarded = byName.get(target)\n if (guarded === undefined) {\n fail(`${entity.name} inherits ${target}'s Read, but ${target} is not listed`)\n }\n if (readRules(guarded).length === 0) {\n fail(`${entity.name} inherits ${target}'s Read, but ${target} has no Read rule`)\n }\n targets.push(target)\n },\n })\n }\n inherits.set(entity.name, targets)\n }\n // A loop of inherited Reads would be a subquery that never ends.\n const closure = (name: string, path: ReadonlyArray<string>): ReadonlyArray<string> => {\n if (path.includes(name)) fail(`inherited Reads loop: ${[...path, name].join(' → ')}`)\n return [name, ...(inherits.get(name) ?? []).flatMap(next => closure(next, [...path, name]))]\n }\n const reaches = new Map(\n entities.map(entity => [entity.name, [...new Set(closure(entity.name, []))]]),\n )\n\n const compile = (\n name: string,\n binding: AnyEntityBinding,\n conditions: ReadonlyMap<string, Condition>,\n input: Readonly<Record<string, unknown>>,\n ): SQL | undefined => {\n const of = (condition: Condition): SQL | undefined =>\n Match.valueTags(condition, {\n Always: () => undefined,\n Never: () => nothing,\n // By the tables the rule was checked against: the SQL one given here, and\n // the policy's for what is decided from the input alone, as Guard judges.\n Row: ({ guard }) =>\n and(\n ...compileWhere(\n guard.query,\n { ...binding, operators: { memory: policy.operators, sql: sqlOperators } },\n input,\n `${name}.${guard.name}`,\n ),\n ),\n And: ({ conditions: parts }) => and(...parts.map(of)),\n // `Condition.or` folds away a part that admits every row, so each part here is SQL.\n Or: ({ conditions: parts }) => or(...parts.map(of)),\n Inherit: ({ relation }) => {\n const storage = binding.relations[relation]\n if (storage === undefined || storage.kind !== 'one') {\n return fail(\n `${name}.${relation} is inherited, so it must be stored as a foreign key here`,\n )\n }\n const target = storage.entity\n const where = compile(target.name, target, conditions, input) ?? sql`1 = 1`\n return sql`${storage.field} in (select ${idColumn(target)} from ${target.table} where ${where})`\n },\n })\n return of(conditions.get(name)!)\n }\n\n const visible =\n (name: string): Visible =>\n (principal, self) => {\n if (!policy.isPrincipal(principal)) {\n return Effect.die(\n new Error(`[foldkit-guard] ${name}: the principal is not an Option of the guard set's`),\n )\n }\n return Effect.flatMap(\n Effect.forEach(reaches.get(name)!, each =>\n Effect.map(\n policy.readable(byName.get(each)!, principal),\n condition => [each, condition] as const,\n ),\n ),\n decided =>\n Effect.try({\n try: () => compile(name, self, new Map(decided), policy.inputOf(principal)),\n catch: error =>\n new RemoteServerError({\n message: error instanceof Error ? error.message : String(error),\n }),\n }),\n )\n }\n return Object.fromEntries(\n entities.map(entity => [entity.name, rowRules.add(visible(entity.name), policy, [entity])]),\n ) as {\n readonly [K in Es[number]['name']]: Visible\n }\n },\n}\n"],"mappings":"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"}
1
+ {"version":3,"file":"drizzle.mjs","names":[],"sources":["../src/drizzle.ts"],"sourcesContent":["/**\n * A guard set's read rules as `foldkit-remote-drizzle` bindings' `visible`:\n * each principal guard decided, what is left compiled to SQL over the table,\n * and an inherited Read a subquery over the related table's own rule.\n */\nimport { and, or, sql, type SQL } from 'drizzle-orm'\nimport { Effect, Match, Option } from 'effect'\nimport { Query, type AnyEntity } from 'foldkit-entity'\nimport {\n DrizzleOperators,\n bodyOperations,\n compileWhere,\n idColumn,\n type AnyEntityBinding,\n type Visible,\n} from 'foldkit-remote-drizzle'\nimport { RemoteServerError } from 'foldkit-remote-server'\nimport { attached, flattenRules, type AnyRule } from './attach.js'\nimport type { Condition } from './condition.js'\nimport type { Policy } from './index.js'\nimport { rowRules } from './placed.js'\n\n// A declaration, not an arrow, so a call narrows what follows it.\nfunction fail(message: string): never {\n throw new Error(`[foldkit-guard] GuardDrizzle.visible: ${message}`)\n}\n\n/** Every rule that decides who may read a row of `entity`. */\nconst readRules = (entity: AnyEntity): ReadonlyArray<AnyRule> =>\n Option.match(attached(entity), {\n onNone: () => [],\n onSome: attachment => [...attachment.always, ...(attachment.row['Read']?.rules ?? [])],\n })\n\nconst nothing = sql`1 = 0`\n\nexport const GuardDrizzle = {\n /**\n * The `visible` rule of each of `entities`, the Entities as `Guards.attach`\n * returned them, by name, for `bind`'s storage. Checked here, before any\n * request: a row guard this compiler cannot run, and an inherited Read whose\n * Entity is not listed, has no Read rule, or leads back to itself, throw.\n * `operators` is the SQL table each rule is checked against here and compiled\n * by (the kernel's when not given), and the policy's table decides what a rule\n * reads from the input alone, so a server that starts can compile every rule\n * whatever table its bindings were given. Give it the bindings' SQL table, so\n * a rule and a query over one operator compile it alike.\n *\n * ```ts\n * const visible = GuardDrizzle.visible(Policy, [Todo, Project])\n * bind(Domain, { Todo: { table: todos, visible: visible.Todo, … }, … })\n * ```\n */\n visible: <User, const Es extends ReadonlyArray<AnyEntity>>(\n policy: Policy<User>,\n entities: Es,\n options: { readonly operators?: DrizzleOperators | undefined } = {},\n ): { readonly [K in Es[number]['name']]: Visible } => {\n const sqlOperators = options.operators ?? DrizzleOperators.kernel\n const byName = new Map(entities.map(entity => [entity.name, entity] as const))\n const inherits = new Map<string, ReadonlyArray<string>>()\n for (const entity of entities) {\n const targets: Array<string> = []\n for (const rule of flattenRules(readRules(entity))) {\n Match.valueTags(rule, {\n PrincipalGuard: () => {},\n RowGuard: guard => {\n const missing = Query.unsupported(guard.query, bodyOperations, sqlOperators)\n if (missing.length > 0) {\n fail(\n `${entity.name}'s ${guard.name} needs ${missing.join(', ')}, which SQL here does not run`,\n )\n }\n },\n All: () => {},\n Inherit: ({ relation }) => {\n const target = entity.relations[relation]!.target().name\n const guarded = byName.get(target)\n if (guarded === undefined) {\n fail(`${entity.name} inherits ${target}'s Read, but ${target} is not listed`)\n }\n if (readRules(guarded).length === 0) {\n fail(`${entity.name} inherits ${target}'s Read, but ${target} has no Read rule`)\n }\n targets.push(target)\n },\n })\n }\n inherits.set(entity.name, targets)\n }\n // A loop of inherited Reads would be a subquery that never ends.\n const closure = (name: string, path: ReadonlyArray<string>): ReadonlyArray<string> => {\n if (path.includes(name)) fail(`inherited Reads loop: ${[...path, name].join(' → ')}`)\n return [name, ...(inherits.get(name) ?? []).flatMap(next => closure(next, [...path, name]))]\n }\n const reaches = new Map(\n entities.map(entity => [entity.name, [...new Set(closure(entity.name, []))]]),\n )\n\n const compile = (\n name: string,\n binding: AnyEntityBinding,\n conditions: ReadonlyMap<string, Condition>,\n input: Readonly<Record<string, unknown>>,\n ): SQL | undefined => {\n const of = (condition: Condition): SQL | undefined =>\n Match.valueTags(condition, {\n Always: () => undefined,\n Never: () => nothing,\n // By the tables the rule was checked against: the SQL one given here, and\n // the policy's for what is decided from the input alone, as Guard judges.\n // A rule reads the rows it reaches as they are stored: it is the server's\n // decision, as a principal guard's body is, not a read by the principal.\n Row: ({ guard, context }) =>\n and(\n ...compileWhere(\n guard.query,\n {\n ...binding,\n operators: { memory: policy.operators, sql: sqlOperators },\n context,\n visibleOf: () => Option.none(),\n },\n input,\n `${name}.${guard.name}`,\n ),\n ),\n And: ({ conditions: parts }) => and(...parts.map(of)),\n // `Condition.or` folds away a part that admits every row, so each part here is SQL.\n Or: ({ conditions: parts }) => or(...parts.map(of)),\n Inherit: ({ relation }) => {\n const storage = binding.relations[relation]\n if (storage === undefined || storage.kind !== 'one') {\n return fail(\n `${name}.${relation} is inherited, so it must be stored as a foreign key here`,\n )\n }\n const target = storage.entity\n const where = compile(target.name, target, conditions, input) ?? sql`1 = 1`\n return sql`${storage.field} in (select ${idColumn(target)} from ${target.table} where ${where})`\n },\n })\n return of(conditions.get(name)!)\n }\n\n const visible =\n (name: string): Visible =>\n (principal, self) => {\n if (!policy.isPrincipal(principal)) {\n return Effect.die(\n new Error(`[foldkit-guard] ${name}: the principal is not an Option of the guard set's`),\n )\n }\n return Effect.flatMap(\n Effect.forEach(reaches.get(name)!, each =>\n Effect.map(\n policy.readable(byName.get(each)!, principal),\n condition => [each, condition] as const,\n ),\n ),\n decided =>\n Effect.try({\n try: () => compile(name, self, new Map(decided), policy.inputOf(principal)),\n catch: error =>\n new RemoteServerError({\n message: error instanceof Error ? error.message : String(error),\n }),\n }),\n )\n }\n return Object.fromEntries(\n entities.map(entity => [entity.name, rowRules.add(visible(entity.name), policy, [entity])]),\n ) as {\n readonly [K in Es[number]['name']]: Visible\n }\n },\n}\n"],"mappings":";;;;;;;;;;;;;AAuBA,SAAS,KAAK,SAAwB;CACpC,MAAM,IAAI,MAAM,yCAAyC,SAAS;AACpE;;AAGA,MAAM,aAAa,WACjB,OAAO,MAAM,SAAS,MAAM,GAAG;CAC7B,cAAc,CAAC;CACf,SAAQ,eAAc,CAAC,GAAG,WAAW,QAAQ,GAAI,WAAW,IAAI,OAAO,EAAE,SAAS,CAAC,CAAE;AACvF,CAAC;AAEH,MAAM,UAAU,GAAG;AAEnB,MAAa,eAAe;;;;;;;;;;;;;;;;;AAiB1B,UACE,QACA,UACA,UAAiE,CAAC,MACd;CACpD,MAAM,eAAe,QAAQ,aAAa,iBAAiB;CAC3D,MAAM,SAAS,IAAI,IAAI,SAAS,KAAI,WAAU,CAAC,OAAO,MAAM,MAAM,CAAU,CAAC;CAC7E,MAAM,2BAAW,IAAI,IAAmC;CACxD,KAAK,MAAM,UAAU,UAAU;EAC7B,MAAM,UAAyB,CAAC;EAChC,KAAK,MAAM,QAAQ,aAAa,UAAU,MAAM,CAAC,GAC/C,MAAM,UAAU,MAAM;GACpB,sBAAsB,CAAC;GACvB,WAAU,UAAS;IACjB,MAAM,UAAU,MAAM,YAAY,MAAM,OAAO,gBAAgB,YAAY;IAC3E,IAAI,QAAQ,SAAS,GACnB,KACE,GAAG,OAAO,KAAK,KAAK,MAAM,KAAK,SAAS,QAAQ,KAAK,IAAI,EAAE,8BAC7D;GAEJ;GACA,WAAW,CAAC;GACZ,UAAU,EAAE,eAAe;IACzB,MAAM,SAAS,OAAO,UAAU,SAAS,CAAE,OAAO,CAAC,CAAC;IACpD,MAAM,UAAU,OAAO,IAAI,MAAM;IACjC,IAAI,YAAY,KAAA,GACd,KAAK,GAAG,OAAO,KAAK,YAAY,OAAO,eAAe,OAAO,eAAe;IAE9E,IAAI,UAAU,OAAO,CAAC,CAAC,WAAW,GAChC,KAAK,GAAG,OAAO,KAAK,YAAY,OAAO,eAAe,OAAO,kBAAkB;IAEjF,QAAQ,KAAK,MAAM;GACrB;EACF,CAAC;EAEH,SAAS,IAAI,OAAO,MAAM,OAAO;CACnC;CAEA,MAAM,WAAW,MAAc,SAAuD;EACpF,IAAI,KAAK,SAAS,IAAI,GAAG,KAAK,yBAAyB,CAAC,GAAG,MAAM,IAAI,CAAC,CAAC,KAAK,KAAK,GAAG;EACpF,OAAO,CAAC,MAAM,IAAI,SAAS,IAAI,IAAI,KAAK,CAAC,EAAA,CAAG,SAAQ,SAAQ,QAAQ,MAAM,CAAC,GAAG,MAAM,IAAI,CAAC,CAAC,CAAC;CAC7F;CACA,MAAM,UAAU,IAAI,IAClB,SAAS,KAAI,WAAU,CAAC,OAAO,MAAM,CAAC,GAAG,IAAI,IAAI,QAAQ,OAAO,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAC9E;CAEA,MAAM,WACJ,MACA,SACA,YACA,UACoB;EACpB,MAAM,MAAM,cACV,MAAM,UAAU,WAAW;GACzB,cAAc,KAAA;GACd,aAAa;GAKb,MAAM,EAAE,OAAO,cACb,IACE,GAAG,aACD,MAAM,OACN;IACE,GAAG;IACH,WAAW;KAAE,QAAQ,OAAO;KAAW,KAAK;IAAa;IACzD;IACA,iBAAiB,OAAO,KAAK;GAC/B,GACA,OACA,GAAG,KAAK,GAAG,MAAM,MACnB,CACF;GACF,MAAM,EAAE,YAAY,YAAY,IAAI,GAAG,MAAM,IAAI,EAAE,CAAC;GAEpD,KAAK,EAAE,YAAY,YAAY,GAAG,GAAG,MAAM,IAAI,EAAE,CAAC;GAClD,UAAU,EAAE,eAAe;IACzB,MAAM,UAAU,QAAQ,UAAU;IAClC,IAAI,YAAY,KAAA,KAAa,QAAQ,SAAS,OAC5C,OAAO,KACL,GAAG,KAAK,GAAG,SAAS,0DACtB;IAEF,MAAM,SAAS,QAAQ;IACvB,MAAM,QAAQ,QAAQ,OAAO,MAAM,QAAQ,YAAY,KAAK,KAAK,GAAG;IACpE,OAAO,GAAG,GAAG,QAAQ,MAAM,cAAc,SAAS,MAAM,EAAE,QAAQ,OAAO,MAAM,SAAS,MAAM;GAChG;EACF,CAAC;EACH,OAAO,GAAG,WAAW,IAAI,IAAI,CAAE;CACjC;CAEA,MAAM,WACH,UACA,WAAW,SAAS;EACnB,IAAI,CAAC,OAAO,YAAY,SAAS,GAC/B,OAAO,OAAO,oBACZ,IAAI,MAAM,mBAAmB,KAAK,oDAAoD,CACxF;EAEF,OAAO,OAAO,QACZ,OAAO,QAAQ,QAAQ,IAAI,IAAI,IAAI,SACjC,OAAO,IACL,OAAO,SAAS,OAAO,IAAI,IAAI,GAAI,SAAS,IAC5C,cAAa,CAAC,MAAM,SAAS,CAC/B,CACF,IACA,YACE,OAAO,IAAI;GACT,WAAW,QAAQ,MAAM,MAAM,IAAI,IAAI,OAAO,GAAG,OAAO,QAAQ,SAAS,CAAC;GAC1E,QAAO,UACL,IAAI,kBAAkB,EACpB,SAAS,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,EAChE,CAAC;EACL,CAAC,CACL;CACF;CACF,OAAO,OAAO,YACZ,SAAS,KAAI,WAAU,CAAC,OAAO,MAAM,SAAS,IAAI,QAAQ,OAAO,IAAI,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAC5F;AAGF,EACF"}
package/dist/index.d.mts CHANGED
@@ -1,2 +1,2 @@
1
- import { A as May, C as PrincipalGuard, D as RowSpec, E as RowGuard, F as RowRule, M as MaySchema, N as Condition, O as ME, P as MemberRead, S as Policy, T as PrincipalSpec, _ as Builders, a as Deny, b as Guards, c as Interaction, d as Redact, f as RuleFor, g as Body, h as AnyGuard, i as Attachment, j as MayAnswer, k as MeEntity, l as InteractionKey, m as About, n as AnyRule, o as Explain, p as Surface, r as Attach, s as Inherit, t as All, u as On, v as Decision, w as PrincipalOf, x as Placeholders, y as GuardSet } from "./attach-BepaL930.mjs";
1
+ import { A as May, C as PrincipalGuard, D as RowSpec, E as RowGuard, F as RowRule, M as MaySchema, N as Condition, O as ME, P as MemberRead, S as Policy, T as PrincipalSpec, _ as Builders, a as Deny, b as Guards, c as Interaction, d as Redact, f as RuleFor, g as Body, h as AnyGuard, i as Attachment, j as MayAnswer, k as MeEntity, l as InteractionKey, m as About, n as AnyRule, o as Explain, p as Surface, r as Attach, s as Inherit, t as All, u as On, v as Decision, w as PrincipalOf, x as Placeholders, y as GuardSet } from "./attach-CJl-GtbN.mjs";
2
2
  export { About, type All, AnyGuard, type AnyRule, type Attach, type Attachment, Body, Builders, Condition, Decision, type Deny, type Explain, GuardSet, Guards, type Inherit, Interaction, type InteractionKey, ME, May, type MayAnswer, MaySchema, type MeEntity, type MemberRead, type On, Placeholders, Policy, PrincipalGuard, PrincipalOf, PrincipalSpec, type Redact, RowGuard, type RowRule, RowSpec, type RuleFor, type Surface };