foldkit-entity 0.12.0 → 0.13.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.
@@ -85,14 +85,17 @@ type Law = Data.TaggedEnum<{
85
85
  readonly domain: Option.Option<Schema.Top>;
86
86
  };
87
87
  }>;
88
- /** A law as JSON says it: what `describeTable` lists and evidence names. */
89
- interface LawDescription {
90
- readonly kind: string;
91
- /** Its witnesses: values as stored, operators by name. */
92
- readonly witnesses: Readonly<Record<string, unknown>>;
93
- /** Its domain as a JSON Schema, or `null` for the operator's whole input. */
94
- readonly domain: unknown;
95
- }
88
+ /**
89
+ * A law as JSON says it: what `Operators.describe` lists and evidence names.
90
+ * Its witnesses are values as stored and operators by name; its domain is a
91
+ * JSON Schema, or `null` for the operator's whole input.
92
+ */
93
+ declare const LawDescription: Schema.Struct<{
94
+ readonly kind: Schema.String;
95
+ readonly witnesses: Schema.$Record<Schema.String, Schema.Unknown>;
96
+ readonly domain: Schema.Unknown;
97
+ }>;
98
+ type LawDescription = typeof LawDescription.Type;
96
99
  declare const Law: {
97
100
  associative: {
98
101
  readonly _tag: "Associative";
@@ -278,6 +281,12 @@ declare const Law: {
278
281
  readonly domain: Option.Option<Schema.Top>;
279
282
  }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Absorbing" | "Associative" | "Commutative" | "Distributes" | "Idempotent" | "Identity" | "Inverse" | "Monotonic" | "PreservesCollation"]>>;
280
283
  };
284
+ /**
285
+ * The operators a law, as JSON, calls besides its own (`inverse`'s and
286
+ * `distributes`' witnesses), by name: evidence of it is of their
287
+ * implementations too, and goes when one of them is replaced.
288
+ */
289
+ witnessesNamed: (law: LawDescription) => ReadonlyArray<string>;
281
290
  /** The law as JSON: its kind, its witnesses (operators by name) and its domain's JSON Schema. */
282
291
  describe: (law: Law) => LawDescription;
283
292
  };
@@ -362,9 +371,20 @@ interface OperatorDescriptor {
362
371
  interface OperatorTable {
363
372
  /** Whether this table implements the operator. */
364
373
  readonly has: (operator: OperatorDescriptor) => boolean;
374
+ /**
375
+ * The versions of the operator `id` it implements: what a refusal of a call
376
+ * to another version names, since a client and a server on different
377
+ * deploys can disagree on one.
378
+ */
379
+ readonly versions: (id: string) => ReadonlyArray<number>;
365
380
  }
366
381
  /** A table implementing nothing: every primitive operator is unsupported by it. */
367
382
  declare const noOperators: OperatorTable;
383
+ /**
384
+ * An operator `operators` does not implement, by name, with the versions of it
385
+ * the table does implement: `acme.slug@2 (this table has acme.slug)`.
386
+ */
387
+ declare const missingName: (operator: OperatorDescriptor, operators: OperatorTable) => string;
368
388
  /**
369
389
  * A call of an operator whose result is a scalar. `expansion` is the
370
390
  * expression it means, built from its arguments when it was called: an
@@ -680,6 +700,12 @@ declare const Expr: {
680
700
  * out. A call with no definition stays, for the interpreter to run or refuse
681
701
  * by name.
682
702
  */
703
+ /**
704
+ * Whether a constant written in these expressions is text holding a NUL, or
705
+ * a list holding one: SQL refuses such a parameter wherever it compiles, so
706
+ * an interpreter refuses the run, not one row.
707
+ */
708
+ givesNul: (...nodes: ReadonlyArray<AnyExpr | Predicate>) => boolean;
683
709
  expanded: <N extends Predicate | AnyExpr>(node: N) => N extends Predicate ? Predicate : AnyExpr;
684
710
  /**
685
711
  * What these expressions need that an interpreter lacks, as `Query.unsupported`
@@ -741,7 +767,7 @@ declare const Expr: {
741
767
  * nullable column that should match everything on an empty search says so:
742
768
  * `Expr.or(Expr.isNull(field), Expr.contains(field, input.search))`.
743
769
  */
744
- contains: <L extends TextOperand>(value: L, search: string | Expr<string>) => ContainsPredicate & Reads<ReadsOf<L>>;
770
+ contains: <L extends TextOperand>(value: L, search: string | LiteralExpr<string> | InputExpr<string> | InputExpr<string | null>) => ContainsPredicate & Reads<ReadsOf<L>>;
745
771
  /**
746
772
  * Whether a value is one of `among`: a list written out, or an input whose
747
773
  * value is one. Each element is compared as `eq` compares.
@@ -981,6 +1007,12 @@ declare const Query: {
981
1007
  placement: (self: AnyQuery, input: Readonly<Record<string, unknown>>, options?: {
982
1008
  readonly operators?: OperatorTable | undefined;
983
1009
  }) => Placement;
1010
+ /**
1011
+ * Each operator the body calls, by name (`id`, or `id@version` past the
1012
+ * first), in the order it first calls them: a defined one, and each
1013
+ * primitive one its expansion calls.
1014
+ */
1015
+ operators: (self: AnyQuery) => ReadonlyArray<string>;
984
1016
  /**
985
1017
  * What the whole query reads: the fields and inputs of every predicate and
986
1018
  * every ordering term, and the operations it uses, with the fields also
@@ -1023,6 +1055,7 @@ declare const Query: {
1023
1055
  */
1024
1056
  show: (self: AnyQuery) => string;
1025
1057
  };
1058
+ declare const testedByRunner: (record: Evidence) => boolean;
1026
1059
  /** What an implementation is told besides its arguments. */
1027
1060
  interface OperatorContext {
1028
1061
  /** The collation the call compares text under, from its operator's `collation` rule. */
@@ -1153,17 +1186,43 @@ declare const Evidence: {
1153
1186
  type TestedEvidence = Extract<Evidence, {
1154
1187
  readonly _tag: 'Tested';
1155
1188
  }>;
1156
- /** One operator a table implements, as `Operators.describeTable` lists it. */
1157
- interface ImplementedOperator {
1158
- /** By id, and `@version` past the first. */
1159
- readonly operator: string;
1160
- readonly laws: ReadonlyArray<LawDescription>;
1189
+ /**
1190
+ * An operator as JSON, by its signature and never its body (a defined
1191
+ * operator says `defined`, not what it means): what a server can publish of
1192
+ * what a body may call, and a client compare with what it runs. Its schemas
1193
+ * are each argument's and the result's stored side, as JSON Schemas.
1194
+ */
1195
+ declare const OperatorDescription: Schema.Struct<{
1196
+ /** By id, and `@version` past the first: what tables, evidence and refusals name. */
1197
+ readonly name: Schema.String;
1198
+ readonly id: Schema.String;
1199
+ readonly version: Schema.Int;
1200
+ readonly description: Schema.NullOr<Schema.String>;
1201
+ readonly input: Schema.$Array<Schema.$Record<Schema.String, Schema.Unknown>>;
1202
+ readonly output: Schema.$Record<Schema.String, Schema.Unknown>;
1203
+ readonly nulls: Schema.Literals<readonly ["strict", "handled"]>;
1204
+ readonly collation: Schema.Literals<readonly ["none", "operands", "required"]>;
1205
+ readonly laws: Schema.$Array<Schema.Struct<{
1206
+ readonly kind: Schema.String;
1207
+ readonly witnesses: Schema.$Record<Schema.String, Schema.Unknown>;
1208
+ readonly domain: Schema.Unknown;
1209
+ }>>;
1210
+ readonly defined: Schema.Boolean;
1211
+ }>;
1212
+ type OperatorDescription = typeof OperatorDescription.Type;
1213
+ /** One operator a table implements, as `Operators.describeTable` lists it: described, with its evidence. */
1214
+ interface ImplementedOperator extends OperatorDescription {
1161
1215
  readonly evidence: ReadonlyArray<Evidence>;
1162
1216
  }
1163
1217
  /** The in-memory interpreter's implementations, by operator. */
1164
1218
  interface MemoryOperators extends OperatorTable {
1165
1219
  readonly _tag: 'MemoryOperators';
1166
1220
  readonly get: (operator: OperatorDescriptor) => Option.Option<MemoryImplementation['run']>;
1221
+ /**
1222
+ * The operator it implements under a name (`id`, or `id@version` past the
1223
+ * first): how a computed assignment carried as data finds what to run.
1224
+ */
1225
+ readonly named: (name: string) => Option.Option<OperatorDescriptor>;
1167
1226
  /** Whether each answer is checked against its operator's output schema: for tests. */
1168
1227
  readonly checked: boolean;
1169
1228
  readonly implementations: ReadonlyArray<MemoryImplementation>;
@@ -1200,16 +1259,38 @@ declare const Operators: {
1200
1259
  /**
1201
1260
  * The table with what is known of its implementations' laws recorded: each
1202
1261
  * record of an operator it implements and a law that operator declares.
1203
- * `Conformance.laws` gives `Tested` records; `Evidence.Proven` says a proof
1204
- * elsewhere covers one.
1262
+ * `Conformance.laws` gives `Tested` records, each of the implementation it
1263
+ * ran, and a table takes only those of its own; `Evidence.Proven` says a
1264
+ * proof elsewhere covers one.
1205
1265
  */
1206
1266
  withEvidence: (base: MemoryOperators, evidence: ReadonlyArray<Evidence>) => MemoryOperators;
1267
+ /**
1268
+ * The memory implementation `Conformance.laws` tested a record on; none for
1269
+ * a record of a runner (`Conformance.lawsBy`) or a proof.
1270
+ */
1271
+ testedOn: (record: Evidence) => Option.Option<MemoryImplementation>;
1272
+ /**
1273
+ * Whether `Conformance.lawsBy` made a record, through a runner: what an SQL
1274
+ * table takes. Which runner it was, the database's or another, is the
1275
+ * caller's word; a record built by hand, copied, or tested in memory is not.
1276
+ */
1277
+ testedByRunner: typeof testedByRunner;
1207
1278
  /**
1208
1279
  * Each operator the table implements, by name, with the laws it declares and
1209
1280
  * the evidence the table records of them: what a server can publish of how
1210
1281
  * it runs a body. JSON as it is.
1211
1282
  */
1212
1283
  describeTable: (base: MemoryOperators) => ReadonlyArray<ImplementedOperator>;
1284
+ /**
1285
+ * An operator as JSON (`OperatorDescription`): its name, version and
1286
+ * description, each argument's and its result's stored side as a JSON
1287
+ * Schema (as JSON carries it: a number also admits the strings `"Infinity"`,
1288
+ * `"-Infinity"` and `"NaN"`), its null and collation rules, its laws, and
1289
+ * whether it is defined. Its signature, never its body.
1290
+ */
1291
+ describe: (operator: {
1292
+ readonly descriptor: OperatorDescriptor;
1293
+ }) => OperatorDescription;
1213
1294
  /**
1214
1295
  * The table, checking every answer against its operator's output schema, so
1215
1296
  * an implementation that answers the wrong kind fails where it answered. For
@@ -1233,8 +1314,18 @@ declare class OperatorMissingError extends QueryEvaluateError {
1233
1314
  readonly operator: OperatorDescriptor;
1234
1315
  /** The operator by its id, and its version past the first. */
1235
1316
  readonly named: string;
1236
- constructor(operator: OperatorDescriptor);
1317
+ /** `operators`, the table that lacks it, names the versions of it that it does hold. */
1318
+ constructor(operator: OperatorDescriptor, operators?: OperatorTable);
1237
1319
  }
1320
+ /**
1321
+ * A primitive operator over stored values, as a call of it is run: what a
1322
+ * computed assignment comes to (`Write.apply`). Refused, as a call is, when
1323
+ * `operators` does not implement it.
1324
+ */
1325
+ declare const applyOperator: (operator: OperatorDescriptor, values: ReadonlyArray<unknown>, options: {
1326
+ readonly collation: Option.Option<Collation>;
1327
+ readonly operators: MemoryOperators;
1328
+ }) => unknown;
1238
1329
  /** SQL's unknown: neither true nor false, and a row is kept only on true. */
1239
1330
  type Truth = boolean | 'unknown';
1240
1331
  /**
@@ -1296,6 +1387,25 @@ declare const assertSupported: (body: AnyQuery, operators?: MemoryOperators) =>
1296
1387
  declare const evaluate: (body: AnyQuery, input: Row, rows: ReadonlyArray<Row>, options?: {
1297
1388
  readonly operators?: MemoryOperators | undefined;
1298
1389
  }) => ReadonlyArray<Row>;
1390
+ /** What `evaluateEach` made of each row: those it matched, in order, and those it refused. */
1391
+ interface Evaluated {
1392
+ readonly matched: ReadonlyArray<Row>;
1393
+ readonly refused: ReadonlyArray<Row>;
1394
+ }
1395
+ /**
1396
+ * As `evaluate`, with each row judged alone: a row whose own values are
1397
+ * refused (text holding a NUL, a value an operator fails on) is set aside in
1398
+ * `refused` and the others are still answered. A client judging the rows it
1399
+ * holds wants this, since one bad stored row says nothing about the rest.
1400
+ *
1401
+ * What no single row causes still refuses the run: an operation or operator
1402
+ * the table lacks, an order by a locale collation, an input the body reads
1403
+ * holding a NUL (every row would refuse, and no row is the cause), and order
1404
+ * keys of different kinds across rows.
1405
+ */
1406
+ declare const evaluateEach: (body: AnyQuery, input: Row, rows: ReadonlyArray<Row>, options?: {
1407
+ readonly operators?: MemoryOperators | undefined;
1408
+ }) => Evaluated;
1299
1409
  /** One invariant of an Entity, as its interpreters read it. */
1300
1410
  interface Invariant {
1301
1411
  /** Stable, unique within its Entity: what a refusal names, and forms and logs key on. */
@@ -1391,9 +1501,11 @@ declare const Text: {
1391
1501
  * | the prefix is `''` | true |
1392
1502
  * | otherwise | whether it begins so, compared under the collation |
1393
1503
  *
1394
- * The collation is the text's: a field's declared one, or a call's. `binary`
1395
- * compares exactly; `asciiFold` folds ASCII letters on both sides. Text with
1396
- * none, or with a backend's locale, is refused where the call is written.
1504
+ * The collation is the one its text operands share (a field's declared one,
1505
+ * or a call's), or one given to the call. `binary` compares exactly;
1506
+ * `asciiFold` folds ASCII letters on both sides. Operands declaring
1507
+ * different collations, text with none, or a backend's locale are refused
1508
+ * where the call is written.
1397
1509
  * Prefixes are by character, so non-ASCII and astral text begin as they read.
1398
1510
  *
1399
1511
  * ```ts
@@ -1458,6 +1570,121 @@ interface WriteSet {
1458
1570
  interface WriteIncrement extends WriteSet {
1459
1571
  readonly integer: boolean;
1460
1572
  }
1573
+ /**
1574
+ * One field the write computes (`label := concat(title, ' draft')`): an
1575
+ * expression over the row before the write and the input, every defined
1576
+ * operator in it expanded, so what is carried is primitive calls alone.
1577
+ */
1578
+ interface WriteAssignment {
1579
+ readonly field: AnyField;
1580
+ readonly expr: AnyExpr;
1581
+ }
1582
+ /**
1583
+ * A computed assignment as data, bound to one input: what travels to a server
1584
+ * and sits in a client's pending patch, which holds no descriptor and no
1585
+ * function. A field of the row before the write, a stored value, or a call of
1586
+ * a primitive operator by name (`id`, or `id@version`), with the collation it
1587
+ * compares text under (`null` for none: this is JSON).
1588
+ */
1589
+ type Computation = Data.TaggedEnum<{
1590
+ Field: {
1591
+ readonly key: string;
1592
+ };
1593
+ Value: {
1594
+ readonly value: unknown;
1595
+ };
1596
+ Call: {
1597
+ readonly operator: string;
1598
+ readonly args: ReadonlyArray<Computation>;
1599
+ readonly collation: Collation | null;
1600
+ };
1601
+ }>;
1602
+ declare const Computation: {
1603
+ readonly $is: <Tag extends "Call" | "Field" | "Value">(tag: Tag) => (u: unknown) => u is Extract<{
1604
+ readonly _tag: "Call";
1605
+ readonly operator: string;
1606
+ readonly args: ReadonlyArray<Computation>;
1607
+ readonly collation: Collation | null;
1608
+ }, {
1609
+ readonly _tag: Tag;
1610
+ }> | Extract<{
1611
+ readonly _tag: "Field";
1612
+ readonly key: string;
1613
+ }, {
1614
+ readonly _tag: Tag;
1615
+ }> | Extract<{
1616
+ readonly _tag: "Value";
1617
+ readonly value: unknown;
1618
+ }, {
1619
+ readonly _tag: Tag;
1620
+ }>;
1621
+ readonly $match: {
1622
+ <Cases extends { readonly [Tag in "Call" | "Field" | "Value"]: (args: Extract<{
1623
+ readonly _tag: "Call";
1624
+ readonly operator: string;
1625
+ readonly args: ReadonlyArray<Computation>;
1626
+ readonly collation: Collation | null;
1627
+ } | {
1628
+ readonly _tag: "Field";
1629
+ readonly key: string;
1630
+ } | {
1631
+ readonly _tag: "Value";
1632
+ readonly value: unknown;
1633
+ }, {
1634
+ readonly _tag: Tag;
1635
+ }>) => any; }>(cases: Cases): (value: {
1636
+ readonly _tag: "Call";
1637
+ readonly operator: string;
1638
+ readonly args: ReadonlyArray<Computation>;
1639
+ readonly collation: Collation | null;
1640
+ } | {
1641
+ readonly _tag: "Field";
1642
+ readonly key: string;
1643
+ } | {
1644
+ readonly _tag: "Value";
1645
+ readonly value: unknown;
1646
+ }) => import("effect/Unify").Unify<ReturnType<Cases["Call" | "Field" | "Value"]>>;
1647
+ <Cases extends { readonly [Tag in "Call" | "Field" | "Value"]: (args: Extract<{
1648
+ readonly _tag: "Call";
1649
+ readonly operator: string;
1650
+ readonly args: ReadonlyArray<Computation>;
1651
+ readonly collation: Collation | null;
1652
+ } | {
1653
+ readonly _tag: "Field";
1654
+ readonly key: string;
1655
+ } | {
1656
+ readonly _tag: "Value";
1657
+ readonly value: unknown;
1658
+ }, {
1659
+ readonly _tag: Tag;
1660
+ }>) => any; }>(value: {
1661
+ readonly _tag: "Call";
1662
+ readonly operator: string;
1663
+ readonly args: ReadonlyArray<Computation>;
1664
+ readonly collation: Collation | null;
1665
+ } | {
1666
+ readonly _tag: "Field";
1667
+ readonly key: string;
1668
+ } | {
1669
+ readonly _tag: "Value";
1670
+ readonly value: unknown;
1671
+ }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Call" | "Field" | "Value"]>>;
1672
+ };
1673
+ readonly Call: Data.TaggedEnum.ConstructorFrom<{
1674
+ readonly _tag: "Call";
1675
+ readonly operator: string;
1676
+ readonly args: ReadonlyArray<Computation>;
1677
+ readonly collation: Collation | null;
1678
+ }, "_tag">;
1679
+ readonly Field: Data.TaggedEnum.ConstructorFrom<{
1680
+ readonly _tag: "Field";
1681
+ readonly key: string;
1682
+ }, "_tag">;
1683
+ readonly Value: Data.TaggedEnum.ConstructorFrom<{
1684
+ readonly _tag: "Value";
1685
+ readonly value: unknown;
1686
+ }, "_tag">;
1687
+ };
1461
1688
  /** One input key the write points at another row with: a `one` relation, by the target's id. */
1462
1689
  interface WriteLink {
1463
1690
  readonly key: string;
@@ -1494,6 +1721,8 @@ interface Write<E extends AnyEntity, Fields extends Schema.Struct.Fields> {
1494
1721
  * computed where the write commits: the input key, and the field it moves.
1495
1722
  */
1496
1723
  readonly increments: ReadonlyArray<WriteIncrement>;
1724
+ /** The fields it computes, each from the row before the write and the input. */
1725
+ readonly assignments: ReadonlyArray<WriteAssignment>;
1497
1726
  /** The `one` relations it points elsewhere, in the input's order. */
1498
1727
  readonly links: ReadonlyArray<WriteLink>;
1499
1728
  }
@@ -1510,9 +1739,19 @@ interface RowOptions<Fields extends Schema.Struct.Fields> {
1510
1739
  type NumberKeys<Fields> = { [K in keyof Fields & string]: Fields[K] extends Schema.Top ? Schema.Schema.Type<Fields[K]> extends number ? K : never : never; }[keyof Fields & string];
1511
1740
  /** An update's increments: a number field of the Entity, by the input key holding the amount. */
1512
1741
  type WriteIncrements<E extends AnyEntity, Fields extends Schema.Struct.Fields> = { readonly [K in NumberKeys<{ [F in keyof E['fields']]: E['fields'][F]['schema']; }>]?: NumberKeys<Fields>; };
1513
- /** An update's options: a row's, and what it moves by an amount. */
1742
+ /**
1743
+ * An update's computed fields: each a field of the Entity, by what it comes
1744
+ * to over the row before the write (`row`, each field as `Expr.field`) and
1745
+ * the input. Its kind is checked against the field's where it is declared.
1746
+ */
1747
+ type WriteComputations<E extends AnyEntity, Fields extends Schema.Struct.Fields> = { readonly [F in keyof E['fields'] & string]?: (context: {
1748
+ readonly row: BeforeRow<E>;
1749
+ readonly input: { readonly [K in keyof Fields & string]: InputExpr<Schema.Schema.Type<Fields[K]>>; };
1750
+ }) => AnyExpr; };
1751
+ /** An update's options: a row's, what it moves by an amount, and what it computes. */
1514
1752
  type UpdateOptions<E extends AnyEntity, Fields extends Schema.Struct.Fields> = RowOptions<Fields> & {
1515
1753
  readonly increment?: WriteIncrements<E, Fields>;
1754
+ readonly compute?: WriteComputations<E, Fields>;
1516
1755
  };
1517
1756
  /** `update`: conditioned when given `when`, which the overloads tell apart. */
1518
1757
  interface UpdateWrite {
@@ -1553,6 +1792,8 @@ interface BoundWrite {
1553
1792
  readonly links: Readonly<Record<string, Option.Option<EntityRef>>>;
1554
1793
  /** Each field it moves, by the amount, encoded: added by the server, and predicted over what a client holds. */
1555
1794
  readonly increments: Readonly<Record<string, number>>;
1795
+ /** Each field it computes, as data: run by the server where it writes, predicted by a client. */
1796
+ readonly assignments: Readonly<Record<string, Computation>>;
1556
1797
  }
1557
1798
  declare const Write: {
1558
1799
  /**
@@ -1572,6 +1813,12 @@ declare const Write: {
1572
1813
  * `when` is what the row must hold for the update to land, checked where it
1573
1814
  * commits (`({ input }) => Expr.eq(Post.fields.status, 'draft')`); a row it
1574
1815
  * does not hold of is refused as unmet.
1816
+ *
1817
+ * `compute` sets a field to what an expression comes to over the row before
1818
+ * the write and the input, run where it commits
1819
+ * (`{ label: ({ row }) => concat(row.title, ' draft') }`). It is refused for
1820
+ * a field another key writes, an expression over the row after the write or
1821
+ * another Entity, or one of a kind the field does not store.
1575
1822
  */
1576
1823
  update: UpdateWrite;
1577
1824
  /**
@@ -1603,8 +1850,9 @@ declare const Write: {
1603
1850
  writes: (write: AnyWrite) => ReadonlyArray<AnyField | OneRelation>;
1604
1851
  /**
1605
1852
  * The fields a write reads from the row it writes: those its `when` reads,
1606
- * each it increments, and the revision it expects. What an interpreter
1607
- * must read, and what a startup check judges it could disclose.
1853
+ * each it increments, each its assignments read, and the revision it
1854
+ * expects. What an interpreter must read, and what a startup check judges
1855
+ * it could disclose.
1608
1856
  */
1609
1857
  reads: (write: AnyWrite) => ReadonlyArray<AnyField>;
1610
1858
  /**
@@ -1614,6 +1862,26 @@ declare const Write: {
1614
1862
  * the input is still the whole, validated value.
1615
1863
  */
1616
1864
  bind: <Fields extends Schema.Struct.Fields>(write: Write<AnyEntity, Fields>, value: Schema.Struct.Type<Fields>, keys?: ReadonlyArray<string>) => BoundWrite;
1865
+ /**
1866
+ * The fields of the row before it that a bound write's amounts and
1867
+ * assignments read: what to read to work out the row it leaves.
1868
+ */
1869
+ boundReads: (bound: Pick<BoundWrite, 'increments' | 'assignments'>) => ReadonlyArray<string>;
1870
+ /**
1871
+ * The row a bound write leaves over `row`, the row before it: its values
1872
+ * set, each amount added (a null stays null, as in SQL), and each
1873
+ * assignment computed by `operators` over the row before. `unknown` names
1874
+ * each field it could not work out: one `row` lacks, or holds as no number
1875
+ * for an amount, or an assignment calling an operator the table lacks. That
1876
+ * field keeps what `row` holds. The one computation of this row: a guard
1877
+ * judges it, a writer explains a miss with it, a client predicts it.
1878
+ */
1879
+ apply: (row: Readonly<Record<string, unknown>>, bound: Pick<BoundWrite, 'values' | 'increments' | 'assignments'>, options: {
1880
+ readonly operators: MemoryOperators;
1881
+ }) => {
1882
+ readonly row: Readonly<Record<string, unknown>>;
1883
+ readonly unknown: ReadonlyArray<string>;
1884
+ };
1617
1885
  };
1618
1886
  declare const EntityTypeId: unique symbol;
1619
1887
  type EntityTypeId = typeof EntityTypeId;
@@ -1956,5 +2224,5 @@ declare const Relation: {
1956
2224
  declare const Derived: {
1957
2225
  make: <S extends Schema.Constraint>(schema: S) => DerivedSpec<S>;
1958
2226
  };
1959
- export { Change as $, Ordering as $t, SelectionPage as A, ComparePredicate as At, ConditionedWrite as B, LiteralExpr as Bt, Relation as C, AnyQuery as Ct, RelationSpecs as D, ChosenOrder as Dt, RelationSpec as E, CallOptions as Et, WrittenAs as F, FieldDependency as Ft, WriteSet as G, Operation as Gt, WriteCondition as H, NotPredicate as Ht, WrittenKey as I, FieldExpr as It, Words as J, OperatorTable as Jt, SchemaShape as K, Operator as Kt, WrittenSpec as L, InPredicate as Lt, SelectionTypeId as M, Dependencies as Mt, TargetKey as N, EqPredicate as Nt, Selected as O, ChosenSort as Ot, Unmapped as P, Expr as Pt, BeforeRow as Q, OrderedOperand as Qt, AnyWrite as R, InputExpr as Rt, RelatedSpecs as S, AnyExpr as St, RelationMap as T, CallExpr as Tt, WriteIncrement as U, NullPredicate as Ut, Write as V, NextExpr as Vt, WriteLink as W, Operandish as Wt, Text as X, Order as Xt, ReadFilter as Y, OrPredicate as Yt, AfterRow as Z, OrderTerm as Zt, IdSchemaOf as _, Side as _n, MemoryOperators as _t, DerivedSpecs as a, Reads as an, QueryEvaluateError as at, PageWindow as b, TestedEvidence as bt, EntityDerived as c, TestPredicate as cn, compareRows as ct, EntityInput as d, dependenciesOf as dn, supported as dt, ParameterOf as en, DeclaredInvariant as et, EntityMember as f, isPredicate as fn, truthOver as ft, IdOf as g, LawDescription as gn, MemoryImplementation as gt, EntityTypeId as h, Law as hn, ImplementedOperator as ht, DerivedSpec as i, QueryDependencies as in, PredicateTruth as it, SelectionPageTypeId as j, ContainsPredicate as jt, Selection as k, CompareOperator as kt, EntityField as l, TextOperand as ln, decided as lt, EntityRelation as m, noOperators as mn, Evidence as mt, Cardinality as n, Predicate as nn, Judgement as nt, Entities as o, ReadsOf as on, Row as ot, EntityRef as p, maxQueryNodes as pn, valueOfOperand as pt, SchemaWords as q, OperatorDescriptor as qt, Derived as r, Query as rn, OperatorMissingError as rt, Entity as s, TermOptions as sn, assertSupported as st, AnyEntity as t, Placement as tn, Invariant as tt, EntityIdentity as u, ValueOf as un, evaluate as ut, InputMember as v, Collation as vn, OperatorContext as vt, RelationInput as w, ArgumentOf as wt, Related as x, AndPredicate as xt, NestedInput as y, Operators as yt, BoundWrite as z, Invalid as zt };
1960
- //# sourceMappingURL=index-B9fbDo_-.d.mts.map
2227
+ export { Text as $, Operator as $t, SelectionPage as A, AnyQuery as At, Computation as B, EqPredicate as Bt, Relation as C, Law as Cn, MemoryOperators as Ct, RelationSpecs as D, TestedEvidence as Dt, RelationSpec as E, Collation as En, Operators as Et, WrittenAs as F, ChosenSort as Ft, WriteCondition as G, InputExpr as Gt, Write as H, FieldDependency as Ht, WrittenKey as I, CompareOperator as It, WriteSet as J, NextExpr as Jt, WriteIncrement as K, Invalid as Kt, WrittenSpec as L, ComparePredicate as Lt, SelectionTypeId as M, CallExpr as Mt, TargetKey as N, CallOptions as Nt, Selected as O, AndPredicate as Ot, Unmapped as P, ChosenOrder as Pt, ReadFilter as Q, Operation as Qt, AnyWrite as R, ContainsPredicate as Rt, RelatedSpecs as S, noOperators as Sn, MemoryImplementation as St, RelationMap as T, Side as Tn, OperatorDescription as Tt, WriteAssignment as U, FieldExpr as Ut, ConditionedWrite as V, Expr as Vt, WriteComputations as W, InPredicate as Wt, SchemaWords as X, NullPredicate as Xt, SchemaShape as Y, NotPredicate as Yt, Words as Z, Operandish as Zt, IdSchemaOf as _, ValueOf as _n, supported as _t, DerivedSpecs as a, OrderedOperand as an, Judgement as at, PageWindow as b, maxQueryNodes as bn, Evidence as bt, EntityDerived as c, Placement as cn, PredicateTruth as ct, EntityInput as d, QueryDependencies as dn, applyOperator as dt, OperatorDescriptor as en, AfterRow as et, EntityMember as f, Reads as fn, assertSupported as ft, IdOf as g, TextOperand as gn, evaluateEach as gt, EntityTypeId as h, TestPredicate as hn, evaluate as ht, DerivedSpec as i, OrderTerm as in, Invariant as it, SelectionPageTypeId as j, ArgumentOf as jt, Selection as k, AnyExpr as kt, EntityField as l, Predicate as ln, QueryEvaluateError as lt, EntityRelation as m, TermOptions as mn, decided as mt, Cardinality as n, OrPredicate as nn, Change as nt, Entities as o, Ordering as on, Evaluated as ot, EntityRef as p, ReadsOf as pn, compareRows as pt, WriteLink as q, LiteralExpr as qt, Derived as r, Order as rn, DeclaredInvariant as rt, Entity as s, ParameterOf as sn, OperatorMissingError as st, AnyEntity as t, OperatorTable as tn, BeforeRow as tt, EntityIdentity as u, Query as un, Row as ut, InputMember as v, dependenciesOf as vn, truthOver as vt, RelationInput as w, LawDescription as wn, OperatorContext as wt, Related as x, missingName as xn, ImplementedOperator as xt, NestedInput as y, isPredicate as yn, valueOfOperand as yt, BoundWrite as z, Dependencies as zt };
2228
+ //# sourceMappingURL=index-hu8IYlNc.d.mts.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"index-hu8IYlNc.d.mts","names":["Arr","StoredOf","_$__expr_js0.Operator"],"sources":["../src/collation.ts","../src/law.ts","../src/expr.ts","../src/tested.ts","../src/operators.ts","../src/evaluate.ts","../src/invariant.ts","../src/text.ts","../src/readFilter.ts","../src/words.ts","../src/shape.ts","../src/write.ts","../src/index.ts"],"mappings":"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"}
package/dist/index.d.mts CHANGED
@@ -1,2 +1,2 @@
1
- import { $ as Change, $t as Ordering, A as SelectionPage, At as ComparePredicate, B as ConditionedWrite, Bt as LiteralExpr, C as Relation, Ct as AnyQuery, D as RelationSpecs, Dt as ChosenOrder, E as RelationSpec, Et as CallOptions, F as WrittenAs, Ft as FieldDependency, G as WriteSet, Gt as Operation, H as WriteCondition, Ht as NotPredicate, I as WrittenKey, It as FieldExpr, J as Words, Jt as OperatorTable, K as SchemaShape, Kt as Operator, L as WrittenSpec, Lt as InPredicate, M as SelectionTypeId, Mt as Dependencies, N as TargetKey, Nt as EqPredicate, O as Selected, Ot as ChosenSort, P as Unmapped, Pt as Expr, Q as BeforeRow, Qt as OrderedOperand, R as AnyWrite, Rt as InputExpr, S as RelatedSpecs, St as AnyExpr, T as RelationMap, Tt as CallExpr, U as WriteIncrement, Ut as NullPredicate, V as Write, Vt as NextExpr, W as WriteLink, Wt as Operandish, X as Text, Xt as Order, Y as ReadFilter, Yt as OrPredicate, Z as AfterRow, Zt as OrderTerm, _ as IdSchemaOf, _n as Side, _t as MemoryOperators, a as DerivedSpecs, an as Reads, at as QueryEvaluateError, b as PageWindow, bt as TestedEvidence, c as EntityDerived, cn as TestPredicate, ct as compareRows, d as EntityInput, dn as dependenciesOf, dt as supported, en as ParameterOf, et as DeclaredInvariant, f as EntityMember, fn as isPredicate, ft as truthOver, g as IdOf, gn as LawDescription, gt as MemoryImplementation, h as EntityTypeId, hn as Law, ht as ImplementedOperator, i as DerivedSpec, in as QueryDependencies, it as PredicateTruth, j as SelectionPageTypeId, jt as ContainsPredicate, k as Selection, kt as CompareOperator, l as EntityField, ln as TextOperand, lt as decided, m as EntityRelation, mn as noOperators, mt as Evidence, n as Cardinality, nn as Predicate, nt as Judgement, o as Entities, on as ReadsOf, ot as Row, p as EntityRef, pn as maxQueryNodes, pt as valueOfOperand, q as SchemaWords, qt as OperatorDescriptor, r as Derived, rn as Query, rt as OperatorMissingError, s as Entity, sn as TermOptions, st as assertSupported, t as AnyEntity, tn as Placement, tt as Invariant, u as EntityIdentity, un as ValueOf, ut as evaluate, v as InputMember, vn as Collation, vt as OperatorContext, w as RelationInput, wt as ArgumentOf, x as Related, xt as AndPredicate, y as NestedInput, yt as Operators, z as BoundWrite, zt as Invalid } from "./index-B9fbDo_-.mjs";
2
- export { type AfterRow, AndPredicate, AnyEntity, AnyExpr, AnyQuery, type AnyWrite, ArgumentOf, type BeforeRow, type BoundWrite, CallExpr, CallOptions, Cardinality, type Change, ChosenOrder, ChosenSort, Collation, CompareOperator, ComparePredicate, type ConditionedWrite, ContainsPredicate, type DeclaredInvariant, Dependencies, Derived, DerivedSpec, DerivedSpecs, Entities, Entity, EntityDerived, EntityField, EntityIdentity, EntityInput, EntityMember, EntityRef, EntityRelation, EntityTypeId, EqPredicate, Evidence, Expr, FieldDependency, FieldExpr, IdOf, IdSchemaOf, ImplementedOperator, InPredicate, InputExpr, InputMember, Invalid, type Invariant, type Judgement, Law, LawDescription, LiteralExpr, MemoryImplementation, MemoryOperators, NestedInput, NextExpr, NotPredicate, NullPredicate, Operandish, Operation, Operator, OperatorContext, OperatorDescriptor, OperatorMissingError, OperatorTable, Operators, OrPredicate, Order, OrderTerm, OrderedOperand, Ordering, PageWindow, ParameterOf, Placement, Predicate, PredicateTruth, Query, QueryDependencies, QueryEvaluateError, ReadFilter, Reads, ReadsOf, Related, RelatedSpecs, Relation, RelationInput, RelationMap, RelationSpec, RelationSpecs, Row, SchemaShape, SchemaWords, Selected, Selection, SelectionPage, SelectionPageTypeId, SelectionTypeId, Side, TargetKey, TermOptions, TestPredicate, TestedEvidence, Text, TextOperand, Unmapped, ValueOf, Words, Write, type WriteCondition, type WriteIncrement, type WriteLink, type WriteSet, WrittenAs, WrittenKey, WrittenSpec, assertSupported, compareRows, decided, dependenciesOf, evaluate, isPredicate, maxQueryNodes, noOperators, supported, truthOver, valueOfOperand };
1
+ import { $ as Text, $t as Operator, A as SelectionPage, At as AnyQuery, B as Computation, Bt as EqPredicate, C as Relation, Cn as Law, Ct as MemoryOperators, D as RelationSpecs, Dt as TestedEvidence, E as RelationSpec, En as Collation, Et as Operators, F as WrittenAs, Ft as ChosenSort, G as WriteCondition, Gt as InputExpr, H as Write, Ht as FieldDependency, I as WrittenKey, It as CompareOperator, J as WriteSet, Jt as NextExpr, K as WriteIncrement, Kt as Invalid, L as WrittenSpec, Lt as ComparePredicate, M as SelectionTypeId, Mt as CallExpr, N as TargetKey, Nt as CallOptions, O as Selected, Ot as AndPredicate, P as Unmapped, Pt as ChosenOrder, Q as ReadFilter, Qt as Operation, R as AnyWrite, Rt as ContainsPredicate, S as RelatedSpecs, Sn as noOperators, St as MemoryImplementation, T as RelationMap, Tn as Side, Tt as OperatorDescription, U as WriteAssignment, Ut as FieldExpr, V as ConditionedWrite, Vt as Expr, W as WriteComputations, Wt as InPredicate, X as SchemaWords, Xt as NullPredicate, Y as SchemaShape, Yt as NotPredicate, Z as Words, Zt as Operandish, _ as IdSchemaOf, _n as ValueOf, _t as supported, a as DerivedSpecs, an as OrderedOperand, at as Judgement, b as PageWindow, bn as maxQueryNodes, bt as Evidence, c as EntityDerived, cn as Placement, ct as PredicateTruth, d as EntityInput, dn as QueryDependencies, dt as applyOperator, en as OperatorDescriptor, et as AfterRow, f as EntityMember, fn as Reads, ft as assertSupported, g as IdOf, gn as TextOperand, gt as evaluateEach, h as EntityTypeId, hn as TestPredicate, ht as evaluate, i as DerivedSpec, in as OrderTerm, it as Invariant, j as SelectionPageTypeId, jt as ArgumentOf, k as Selection, kt as AnyExpr, l as EntityField, ln as Predicate, lt as QueryEvaluateError, m as EntityRelation, mn as TermOptions, mt as decided, n as Cardinality, nn as OrPredicate, nt as Change, o as Entities, on as Ordering, ot as Evaluated, p as EntityRef, pn as ReadsOf, pt as compareRows, q as WriteLink, qt as LiteralExpr, r as Derived, rn as Order, rt as DeclaredInvariant, s as Entity, sn as ParameterOf, st as OperatorMissingError, t as AnyEntity, tn as OperatorTable, tt as BeforeRow, u as EntityIdentity, un as Query, ut as Row, v as InputMember, vn as dependenciesOf, vt as truthOver, w as RelationInput, wn as LawDescription, wt as OperatorContext, x as Related, xn as missingName, xt as ImplementedOperator, y as NestedInput, yn as isPredicate, yt as valueOfOperand, z as BoundWrite, zt as Dependencies } from "./index-hu8IYlNc.mjs";
2
+ export { type AfterRow, AndPredicate, AnyEntity, AnyExpr, AnyQuery, type AnyWrite, ArgumentOf, type BeforeRow, type BoundWrite, CallExpr, CallOptions, Cardinality, type Change, ChosenOrder, ChosenSort, Collation, CompareOperator, ComparePredicate, Computation, type ConditionedWrite, ContainsPredicate, type DeclaredInvariant, Dependencies, Derived, DerivedSpec, DerivedSpecs, Entities, Entity, EntityDerived, EntityField, EntityIdentity, EntityInput, EntityMember, EntityRef, EntityRelation, EntityTypeId, EqPredicate, Evaluated, Evidence, Expr, FieldDependency, FieldExpr, IdOf, IdSchemaOf, ImplementedOperator, InPredicate, InputExpr, InputMember, Invalid, type Invariant, type Judgement, Law, LawDescription, LiteralExpr, MemoryImplementation, MemoryOperators, NestedInput, NextExpr, NotPredicate, NullPredicate, Operandish, Operation, Operator, OperatorContext, OperatorDescription, OperatorDescriptor, OperatorMissingError, OperatorTable, Operators, OrPredicate, Order, OrderTerm, OrderedOperand, Ordering, PageWindow, ParameterOf, Placement, Predicate, PredicateTruth, Query, QueryDependencies, QueryEvaluateError, ReadFilter, Reads, ReadsOf, Related, RelatedSpecs, Relation, RelationInput, RelationMap, RelationSpec, RelationSpecs, Row, SchemaShape, SchemaWords, Selected, Selection, SelectionPage, SelectionPageTypeId, SelectionTypeId, Side, TargetKey, TermOptions, TestPredicate, TestedEvidence, Text, TextOperand, Unmapped, ValueOf, Words, Write, type WriteAssignment, type WriteComputations, type WriteCondition, type WriteIncrement, type WriteLink, type WriteSet, WrittenAs, WrittenKey, WrittenSpec, applyOperator, assertSupported, compareRows, decided, dependenciesOf, evaluate, evaluateEach, isPredicate, maxQueryNodes, missingName, noOperators, supported, truthOver, valueOfOperand };
package/dist/index.mjs CHANGED
@@ -1 +1 @@
1
- export { j as Collation, t as Derived, n as Entity, r as EntityTypeId, b as Evidence, C as Expr, A as Law, d as OperatorMissingError, x as Operators, w as Order, T as Query, f as QueryEvaluateError, l as ReadFilter, i as Relation, u as SchemaShape, a as SelectionPageTypeId, o as SelectionTypeId, S as Text, c as Words, s as Write, p as assertSupported, m as compareRows, h as decided, E as dependenciesOf, g as evaluate, D as isPredicate, O as maxQueryNodes, k as noOperators, _ as supported, v as truthOver, y as valueOfOperand } from "./src-CSxcKUv6.mjs";
1
+ export { z as Collation, s as Computation, t as Derived, n as Entity, r as EntityTypeId, S as Evidence, O as Expr, I as Law, L as LawDescription, C as OperatorDescription, d as OperatorMissingError, w as Operators, k as Order, A as Query, f as QueryEvaluateError, u as ReadFilter, i as Relation, R as SchemaShape, a as SelectionPageTypeId, o as SelectionTypeId, T as Text, l as Words, c as Write, p as applyOperator, m as assertSupported, h as compareRows, g as decided, j as dependenciesOf, _ as evaluate, v as evaluateEach, M as isPredicate, N as maxQueryNodes, P as missingName, F as noOperators, y as supported, b as truthOver, x as valueOfOperand } from "./src-DBAilaDV.mjs";