foldkit-entity 0.8.1 → 0.9.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.
@@ -1,4 +1,4 @@
1
- import { Option, Pipeable, Schema, SchemaAST } from "effect";
1
+ import { Array, Option, Pipeable, Schema, SchemaAST } from "effect";
2
2
  import { Metadata } from "foldkit-metadata";
3
3
  //#region src/collation.d.ts
4
4
  type Collation =
@@ -70,7 +70,7 @@ type AnyExpr = Expr<unknown>;
70
70
  * then be confused, which a structural phantom would allow. A scalar-valued
71
71
  * operation, if one is ever needed, joins `Expr` instead.
72
72
  */
73
- type Predicate = EqPredicate | NullPredicate | ContainsPredicate | InPredicate;
73
+ type Predicate = EqPredicate | NullPredicate | ContainsPredicate | InPredicate | AndPredicate | OrPredicate | NotPredicate | ComparePredicate;
74
74
  /** Two values are the same. */
75
75
  interface EqPredicate {
76
76
  readonly _tag: 'Eq';
@@ -108,6 +108,43 @@ interface InPredicate {
108
108
  readonly value: AnyExpr;
109
109
  readonly among: AnyExpr;
110
110
  }
111
+ /**
112
+ * Every operand holds. `Query.where`'s list is already a conjunction; this is
113
+ * one inside something else, `or(and(a, b), c)`. Never empty, and never holding
114
+ * another `and`: `Expr.and` flattens one into its parent.
115
+ */
116
+ interface AndPredicate {
117
+ readonly _tag: 'And';
118
+ readonly operands: Array.NonEmptyReadonlyArray<Predicate>;
119
+ }
120
+ /** At least one operand holds. Never empty, and never holding another `or`. */
121
+ interface OrPredicate {
122
+ readonly _tag: 'Or';
123
+ readonly operands: Array.NonEmptyReadonlyArray<Predicate>;
124
+ }
125
+ /**
126
+ * The operand does not hold. As SQL's `not`, an unknown stays unknown, so a row
127
+ * whose operand is unknown (a null compared) is matched by neither the operand
128
+ * nor its `not`.
129
+ */
130
+ interface NotPredicate {
131
+ readonly _tag: 'Not';
132
+ readonly operand: Predicate;
133
+ }
134
+ /** Which way a comparison orders its two sides: `left < right` for `lt`. */
135
+ type CompareOperator = 'lt' | 'lte' | 'gt' | 'gte';
136
+ /**
137
+ * One scalar orders before, or after, the other. A null on either side is
138
+ * unknown. `collation` is how text compares, decided where the comparison is
139
+ * written (see `Expr.lt`); none for values that order intrinsically, numbers.
140
+ */
141
+ interface ComparePredicate {
142
+ readonly _tag: 'Compare';
143
+ readonly operator: CompareOperator;
144
+ readonly left: AnyExpr;
145
+ readonly right: AnyExpr;
146
+ readonly collation: Option.Option<Collation>;
147
+ }
111
148
  /**
112
149
  * Anything an operation can be given: a scalar, or a predicate where a boolean
113
150
  * is wanted. `Expr.eq(Expr.isNotNull(archivedAt), input.archived)` is the
@@ -140,6 +177,7 @@ type ValueOf<E> = E extends EntityField<string, string, infer S> ? Schema.Schema
140
177
  * defeated that way.
141
178
  */
142
179
  type TextOperand = EntityField<string, string, Schema.Constraint & Schema.Codec<string | null, any, any, any>> | Expr<string> | Expr<string | null>;
180
+ declare const literal: <T>(value: T) => LiteralExpr<T>;
143
181
  /** Whether a value is a predicate, and so usable where a boolean is wanted. */
144
182
  declare const isPredicate: (value: unknown) => value is Predicate;
145
183
  /**
@@ -147,7 +185,7 @@ declare const isPredicate: (value: unknown) => value is Predicate;
147
185
  * runs, and a body needing one it does not is refused rather than answered
148
186
  * wrongly — see `Query.unsupported`.
149
187
  */
150
- type Operation = 'eq' | 'isNull' | 'isNotNull' | 'contains' | 'in';
188
+ type Operation = 'eq' | 'isNull' | 'isNotNull' | 'contains' | 'in' | 'and' | 'or' | 'not' | 'compare';
151
189
  /** One field an expression reads: its Entity's name and key, and the identity that owns it. */
152
190
  interface FieldDependency {
153
191
  /** The owning Entity's name, for display; two Entities may share one. */
@@ -174,9 +212,22 @@ interface QueryDependencies extends Dependencies {
174
212
  readonly predicate: ReadonlyArray<FieldDependency>;
175
213
  readonly order: ReadonlyArray<FieldDependency>;
176
214
  }
215
+ /**
216
+ * A field or scalar whose value orders: a number, text, a date (which orders by
217
+ * its encoded form), or one of those absent. A boolean does not order here.
218
+ * A constraint on the type parameter, as `TextOperand` is, so inference cannot
219
+ * fall back past it.
220
+ */
221
+ type OrderedOperand = EntityField<string, string, Schema.Constraint & Schema.Codec<number | string | Date | null, any, any, any>> | Expr<number> | Expr<number | null> | Expr<string> | Expr<string | null> | Expr<Date> | Expr<Date | null>;
222
+ /** `Expr.and` and `Expr.or`: one operand is that operand, and two or more are one node. */
223
+ interface Connective<Node extends Predicate> {
224
+ <P extends Predicate>(only: P): P;
225
+ (first: Predicate, second: Predicate, ...rest: ReadonlyArray<Predicate>): Node;
226
+ (...operands: Array.NonEmptyReadonlyArray<Predicate>): Predicate;
227
+ }
177
228
  declare const Expr: {
178
229
  /** A constant. Comparisons coerce a plain value, so this is rarely written. */
179
- literal: <T>(value: T) => LiteralExpr<T>;
230
+ literal: typeof literal;
180
231
  /**
181
232
  * A value the query is given when it runs. A definition builds these from its
182
233
  * `Input` schema; written by hand only when constructing a body directly.
@@ -196,8 +247,8 @@ declare const Expr: {
196
247
  eq: <L extends Operand<any>>(left: L, right: ValueOf<L> | Expr<ValueOf<L>> | (boolean extends ValueOf<L> ? Predicate : never)) => EqPredicate;
197
248
  /**
198
249
  * Whether a field holds no value. Its opposite is `isNotNull`; both are the
199
- * one node, because a query asks which of the two it means and nothing here
200
- * can negate a predicate.
250
+ * one node, since a query asks which of the two it means, and `is not null`
251
+ * has no unknown for a `not` to keep.
201
252
  */
202
253
  isNull: <L extends Operand<any>>(operand: L) => NullPredicate;
203
254
  /** Whether a field holds a value. */
@@ -216,8 +267,7 @@ declare const Expr: {
216
267
  * **Over a column that can be null this is not the same as no filter.** A
217
268
  * null contains nothing, not even the empty string, so its rows drop out. A
218
269
  * nullable column that should match everything on an empty search says so:
219
- * `Expr.or` does not exist yet, so for now such a column needs its own
220
- * predicate or a native escape hatch.
270
+ * `Expr.or(Expr.isNull(field), Expr.contains(field, input.search))`.
221
271
  */
222
272
  contains: <L extends TextOperand>(value: L, search: string | Expr<string>) => ContainsPredicate;
223
273
  /**
@@ -234,6 +284,75 @@ declare const Expr: {
234
284
  * copied, so changing the array afterwards does not change the query.
235
285
  */
236
286
  in: <L extends Operand<any>>(value: L, among: ReadonlyArray<ValueOf<L>> | Expr<ReadonlyArray<ValueOf<L>>>) => InPredicate;
287
+ /**
288
+ * `left` orders before `right`. Numbers compare as numbers; text compares
289
+ * under a collation, the one given or the field's declared one, which must be
290
+ * `binary` or `asciiFold` (so every backend agrees), and text needs a field on
291
+ * one side. A date compares by its encoded form: as text when it is stored as
292
+ * an ISO string, so its field declares `Collation.binary`. A null on either
293
+ * side is unknown, so the row is matched by neither this nor its `not`.
294
+ *
295
+ * ```ts
296
+ * Expr.lt(fields.cents, 1000)
297
+ * Expr.and(Expr.gte(fields.at, input.from), Expr.lt(fields.at, input.until))
298
+ * ```
299
+ */
300
+ lt: <L extends OrderedOperand>(left: L, right: ValueOf<L> | Expr<ValueOf<L>>, options?: {
301
+ readonly collation?: Collation | undefined;
302
+ }) => ComparePredicate;
303
+ /** `left` orders before `right`, or with it; see `Expr.lt`. */
304
+ lte: <L extends OrderedOperand>(left: L, right: ValueOf<L> | Expr<ValueOf<L>>, options?: {
305
+ readonly collation?: Collation | undefined;
306
+ }) => ComparePredicate;
307
+ /** `left` orders after `right`; see `Expr.lt`. */
308
+ gt: <L extends OrderedOperand>(left: L, right: ValueOf<L> | Expr<ValueOf<L>>, options?: {
309
+ readonly collation?: Collation | undefined;
310
+ }) => ComparePredicate;
311
+ /** `left` orders after `right`, or with it; see `Expr.lt`. */
312
+ gte: <L extends OrderedOperand>(left: L, right: ValueOf<L> | Expr<ValueOf<L>>, options?: {
313
+ readonly collation?: Collation | undefined;
314
+ }) => ComparePredicate;
315
+ /**
316
+ * Every operand holds, as one predicate to place inside another: `where`'s
317
+ * list is already a conjunction, so this is for `or(and(a, b), c)`.
318
+ * Unknown as SQL's `and` is: false wins over unknown, which wins over true.
319
+ * Needs an operand; a list built at run time is checked non-empty first
320
+ * (`Array.isReadonlyArrayNonEmpty`), since an empty `and` would match every row.
321
+ */
322
+ and: Connective<AndPredicate>;
323
+ /**
324
+ * At least one operand holds:
325
+ *
326
+ * ```ts
327
+ * Expr.or(Expr.contains(fields.description, input.search), Expr.contains(fields.upc, input.search))
328
+ * ```
329
+ *
330
+ * Unknown as SQL's `or` is: true wins over unknown, which wins over false.
331
+ * Needs an operand, since an empty `or` would match no row.
332
+ */
333
+ or: Connective<OrPredicate>;
334
+ /**
335
+ * The operand does not hold. **A null is matched by neither side**:
336
+ * `not(eq(status, 'draft'))` leaves out a row whose `status` is null, since
337
+ * `null = 'draft'` is unknown and so is its `not`, as in SQL. "Everything
338
+ * but drafts" over a nullable column is
339
+ * `Expr.or(Expr.isNull(status), Expr.not(Expr.eq(status, 'draft')))`.
340
+ */
341
+ not: (operand: Predicate) => NotPredicate;
342
+ /**
343
+ * A filter that applies only when its input is given: `or(isNull($x), …)`,
344
+ * with the predicate built from the input as never null.
345
+ *
346
+ * ```ts
347
+ * // Every product, or those of the chosen status.
348
+ * Expr.whenGiven(input.status, status => Expr.eq(fields.status, status))
349
+ * ```
350
+ *
351
+ * An interpreter that runs per request, as the Drizzle compiler does, decides
352
+ * `isNull($x)` before writing SQL, so this compiles to `true`, which filters
353
+ * nothing, or to the predicate alone.
354
+ */
355
+ whenGiven: <T>(input: InputExpr<T>, build: (given: InputExpr<NonNullable<T>>) => Predicate) => Predicate;
237
356
  /** An expression as readable text; see `showExpr` for what it is and is not. */
238
357
  show: (node: Operandish) => string;
239
358
  };
@@ -447,17 +566,19 @@ declare const Words: {
447
566
  };
448
567
  //#endregion
449
568
  //#region src/shape.d.ts
569
+ declare const isNullish: (ast: SchemaAST.AST) => boolean;
570
+ declare const isText: (ast: SchemaAST.AST) => boolean;
450
571
  /** What a schema's AST holds, read through Effect's own guards. */
451
572
  declare const SchemaShape: {
452
573
  /** True for the `null` and `undefined` members that make a schema optional. */
453
- isNullish: (ast: SchemaAST.AST) => boolean;
574
+ isNullish: typeof isNullish;
454
575
  /**
455
576
  * The members of a schema with `null` and `undefined` set aside, so optional
456
577
  * text is still text; a schema that is not a union is its one member.
457
578
  */
458
579
  present: (ast: SchemaAST.AST) => ReadonlyArray<SchemaAST.AST>;
459
580
  /** True when every value the schema admits is a string. */
460
- isText: (ast: SchemaAST.AST) => boolean;
581
+ isText: typeof isText;
461
582
  };
462
583
  //#endregion
463
584
  //#region src/evaluate.d.ts
@@ -466,6 +587,17 @@ type Row = Readonly<Record<string, unknown>>;
466
587
  declare class QueryEvaluateError extends Error {
467
588
  constructor(message: string);
468
589
  }
590
+ /** SQL's unknown: neither true nor false, and a row is kept only on true. */
591
+ type Truth = boolean | 'unknown';
592
+ /** What a predicate comes to: SQL's three values, of which a row is kept only on `true`. */
593
+ type PredicateTruth = Truth;
594
+ /**
595
+ * A predicate's truth from the input alone, when it reads no field; none when
596
+ * it reads one. An interpreter that runs per request decides such a predicate
597
+ * before it builds anything: `isNull($status)` is known before any row is.
598
+ * Refuses what `evaluate` refuses (text holding a NUL).
599
+ */
600
+ declare const decided: (node: Predicate, input: Row) => Option.Option<PredicateTruth>;
469
601
  /**
470
602
  * Where `left` sorts against `right` under these terms (`Query.orderFor`'s),
471
603
  * as `evaluate` sorts: negative when it comes first. Refuses what `evaluate`
@@ -836,6 +968,8 @@ type WrittenKey<M> = M extends EntityField<any, infer Key, any> ? Key : M extend
836
968
  type WrittenAs<M> = M extends NestedInput<any, EntityInput<infer Of, any, infer Members>> ? Selection<Of['name'], WrittenSpec<Members>, SelectionSchema<Of, WrittenSpec<Members>>> : true;
837
969
  /** Every member the input writes: what to read to show the input's current values. */
838
970
  type WrittenSpec<Members> = { readonly [K in keyof Members as WrittenKey<Members[K]>]: WrittenAs<Members[K]>; };
971
+ declare const isSameEntity: (left: AnyEntity, right: AnyEntity) => boolean;
972
+ declare const isEntity: (value: unknown) => value is AnyEntity;
839
973
  declare const Entity: {
840
974
  /** Declares an Entity from its intrinsic fields. Each call is a new identity. */
841
975
  define: <const Name extends string, Fields extends Schema.Struct.Fields>(name: Name, schema: Schema.Struct<Fields>) => Entity<Name, Fields>;
@@ -851,7 +985,7 @@ declare const Entity: {
851
985
  * target, that Selection's value. `many` yields an array, an optional `one`
852
986
  * is nullable.
853
987
  */
854
- select: <E extends AnyEntity, const Spec>(entity: E, spec: Spec & SelectionSpec<E, Spec>) => Selection<E["name"], Spec, SelectionSchema<E, Spec>, IdOf<E>>;
988
+ select: <E extends AnyEntity, const Spec>(entity: E, spec: Spec & SelectionSpec<E, Spec>) => Selection<E['name'], Spec, SelectionSchema<E, Spec>, IdOf<E>>;
855
989
  /**
856
990
  * A `many` relation read a page at a time, in place of its Selection:
857
991
  * `comments: Entity.page(CommentSummary, { first: 10 })`. The value is a page
@@ -863,7 +997,7 @@ declare const Entity: {
863
997
  /** Attaches an interpreter's metadata to the Entity itself. */
864
998
  annotate: (metadata: Metadata) => <E extends AnyEntity>(entity: E) => E;
865
999
  /** Attaches an interpreter's metadata to members, by key. */
866
- annotateMembers: <E extends AnyEntity>(metadata: { readonly [K in keyof E["members"]]?: Metadata; }) => (entity: E) => E;
1000
+ annotateMembers: <E extends AnyEntity>(metadata: { readonly [K in keyof E['members']]?: Metadata; }) => (entity: E) => E;
867
1001
  /**
868
1002
  * Reads an operation's input schema against an Entity. A key that names a
869
1003
  * field maps to it; any other key is mapped explicitly, to a Field, to
@@ -878,12 +1012,12 @@ declare const Entity: {
878
1012
  * struct: `Schema.Struct({ ...Entity.fields(Post, 'id', 'title'), editorId: ... })`.
879
1013
  * The input then keeps the field's own rules, and its keys map themselves.
880
1014
  */
881
- fields: <E extends AnyEntity, const Keys extends ReadonlyArray<keyof E["fields"] & string>>(entity: E, ...keys: Keys) => { readonly [K in Keys[number]]: E["fields"][K]["schema"]; };
1015
+ fields: <E extends AnyEntity, const Keys extends ReadonlyArray<keyof E['fields'] & string>>(entity: E, ...keys: Keys) => { readonly [K in Keys[number]]: E['fields'][K]['schema']; };
882
1016
  /**
883
1017
  * The Selection of every member an input writes, with each relation as refs:
884
1018
  * what an edit screen loads before it shows the input's current values.
885
1019
  */
886
- selectFor: <E extends AnyEntity, Fields extends Schema.Struct.Fields, Members>(input: EntityInput<E, Fields, Members>) => Selection<E["name"], WrittenSpec<Members>, SelectionSchema<E, WrittenSpec<Members>>, IdOf<E>>;
1020
+ selectFor: <E extends AnyEntity, Fields extends Schema.Struct.Fields, Members>(input: EntityInput<E, Fields, Members>) => Selection<E['name'], WrittenSpec<Members>, SelectionSchema<E, WrittenSpec<Members>>, IdOf<E>>;
887
1021
  /**
888
1022
  * The input values that reproduce `value`, a value read through `selectFor`
889
1023
  * (or any Selection with those members): a field as it is, a relation as the
@@ -891,9 +1025,9 @@ declare const Entity: {
891
1025
  * an unmapped key, which the Entity knows nothing about.
892
1026
  */
893
1027
  valuesFor: <E extends AnyEntity, Fields extends Schema.Struct.Fields, Members>(input: EntityInput<E, Fields, Members>, value: Readonly<Record<string, unknown>>) => Partial<Schema.Struct.Type<Fields>>;
894
- is: (value: unknown) => value is AnyEntity;
1028
+ is: typeof isEntity;
895
1029
  /** True when both descriptors are versions of one Entity. */
896
- same: (left: AnyEntity, right: AnyEntity) => boolean;
1030
+ same: typeof isSameEntity;
897
1031
  };
898
1032
  declare function one<Target extends AnyEntity>(target: Target): RelationSpec<Target, 'one', false>;
899
1033
  declare function one<Target extends AnyEntity, const Optional extends boolean>(target: Target, options: {
@@ -909,11 +1043,11 @@ declare const Relation: {
909
1043
  * through `input`, an `Entity.input` of the target. A `many` holds a list.
910
1044
  */
911
1045
  nested: <R extends EntityRelation<any, any, any, any, any>, I extends EntityInput<any, any, any>>(relation: R, input: I) => NestedInput<R, I>;
912
- many: <Target extends AnyEntity>(target: Target) => RelationSpec<Target, "many", false>;
1046
+ many: <Target extends AnyEntity>(target: Target) => RelationSpec<Target, 'many', false>;
913
1047
  };
914
1048
  declare const Derived: {
915
1049
  make: <S extends Schema.Constraint>(schema: S) => DerivedSpec<S>;
916
1050
  };
917
1051
  //#endregion
918
- export { AnyExpr as $, SelectionPage as A, Write as B, Relation as C, TextOperand as Ct, RelationSpecs as D, maxQueryNodes as Dt, RelationSpec as E, isPredicate as Et, WrittenAs as F, assertSupported as G, WriteSet as H, WrittenKey as I, supported as J, compareRows as K, WrittenSpec as L, SelectionTypeId as M, TargetKey as N, Selected as O, Collation as Ot, Unmapped as P, ReadFilter as Q, AnyWrite as R, RelatedSpecs as S, TermOptions as St, RelationMap as T, dependenciesOf as Tt, QueryEvaluateError as U, WriteLink as V, Row as W, SchemaWords as X, SchemaShape as Y, Words as Z, IdSchemaOf as _, Ordering as _t, DerivedSpecs as a, EqPredicate as at, PageWindow as b, Query as bt, EntityDerived as c, FieldExpr as ct, EntityInput as d, LiteralExpr as dt, AnyQuery as et, EntityMember as f, NullPredicate as ft, IdOf as g, OrderTerm as gt, EntityTypeId as h, Order as ht, DerivedSpec as i, Dependencies as it, SelectionPageTypeId as j, Selection as k, EntityField as l, InPredicate as lt, EntityRelation as m, Operation as mt, Cardinality as n, ChosenSort as nt, Entities as o, Expr as ot, EntityRef as p, Operandish as pt, evaluate as q, Derived as r, ContainsPredicate as rt, Entity as s, FieldDependency as st, AnyEntity as t, ChosenOrder as tt, EntityIdentity as u, InputExpr as ut, InputMember as v, Placement as vt, RelationInput as w, ValueOf as wt, Related as x, QueryDependencies as xt, NestedInput as y, Predicate as yt, BoundWrite as z };
919
- //# sourceMappingURL=index-DLz2yED-.d.mts.map
1052
+ export { Words as $, SelectionPage as A, TermOptions as At, Write as B, Relation as C, OrderTerm as Ct, RelationSpecs as D, Predicate as Dt, RelationSpec as E, Placement as Et, WrittenAs as F, maxQueryNodes as Ft, Row as G, WriteSet as H, WrittenKey as I, Collation as It, decided as J, assertSupported as K, WrittenSpec as L, SelectionTypeId as M, ValueOf as Mt, TargetKey as N, dependenciesOf as Nt, Selected as O, Query as Ot, Unmapped as P, isPredicate as Pt, SchemaWords as Q, AnyWrite as R, RelatedSpecs as S, Order as St, RelationMap as T, Ordering as Tt, PredicateTruth as U, WriteLink as V, QueryEvaluateError as W, supported as X, evaluate as Y, SchemaShape as Z, IdSchemaOf as _, NotPredicate as _t, DerivedSpecs as a, ChosenSort as at, PageWindow as b, Operation as bt, EntityDerived as c, ContainsPredicate as ct, EntityInput as d, Expr as dt, ReadFilter as et, EntityMember as f, FieldDependency as ft, IdOf as g, LiteralExpr as gt, EntityTypeId as h, InputExpr as ht, DerivedSpec as i, ChosenOrder as it, SelectionPageTypeId as j, TextOperand as jt, Selection as k, QueryDependencies as kt, EntityField as l, Dependencies as lt, EntityRelation as m, InPredicate as mt, Cardinality as n, AnyExpr as nt, Entities as o, CompareOperator as ot, EntityRef as p, FieldExpr as pt, compareRows as q, Derived as r, AnyQuery as rt, Entity as s, ComparePredicate as st, AnyEntity as t, AndPredicate as tt, EntityIdentity as u, EqPredicate as ut, InputMember as v, NullPredicate as vt, RelationInput as w, OrderedOperand as wt, Related as x, OrPredicate as xt, NestedInput as y, Operandish as yt, BoundWrite as z };
1053
+ //# sourceMappingURL=index-BzdK89FC.d.mts.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"index-BzdK89FC.d.mts","names":["Arr"],"sources":["../src/collation.ts","../src/expr.ts","../src/readFilter.ts","../src/words.ts","../src/shape.ts","../src/evaluate.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 AnyExpr, A as SelectionPage, B as Write, C as Relation, Ct as TextOperand, D as RelationSpecs, Dt as maxQueryNodes, E as RelationSpec, Et as isPredicate, F as WrittenAs, G as assertSupported, H as WriteSet, I as WrittenKey, J as supported, K as compareRows, L as WrittenSpec, M as SelectionTypeId, N as TargetKey, O as Selected, Ot as Collation, P as Unmapped, Q as ReadFilter, R as AnyWrite, S as RelatedSpecs, St as TermOptions, T as RelationMap, Tt as dependenciesOf, U as QueryEvaluateError, V as WriteLink, W as Row, X as SchemaWords, Y as SchemaShape, Z as Words, _ as IdSchemaOf, _t as Ordering, a as DerivedSpecs, at as EqPredicate, b as PageWindow, bt as Query, c as EntityDerived, ct as FieldExpr, d as EntityInput, dt as LiteralExpr, et as AnyQuery, f as EntityMember, ft as NullPredicate, g as IdOf, gt as OrderTerm, h as EntityTypeId, ht as Order, i as DerivedSpec, it as Dependencies, j as SelectionPageTypeId, k as Selection, l as EntityField, lt as InPredicate, m as EntityRelation, mt as Operation, n as Cardinality, nt as ChosenSort, o as Entities, ot as Expr, p as EntityRef, pt as Operandish, q as evaluate, r as Derived, rt as ContainsPredicate, s as Entity, st as FieldDependency, t as AnyEntity, tt as ChosenOrder, u as EntityIdentity, ut as InputExpr, v as InputMember, vt as Placement, w as RelationInput, wt as ValueOf, x as Related, xt as QueryDependencies, y as NestedInput, yt as Predicate, z as BoundWrite } from "./index-DLz2yED-.mjs";
2
- export { AnyEntity, AnyExpr, AnyQuery, type AnyWrite, type BoundWrite, Cardinality, ChosenOrder, ChosenSort, Collation, ContainsPredicate, Dependencies, Derived, DerivedSpec, DerivedSpecs, Entities, Entity, EntityDerived, EntityField, EntityIdentity, EntityInput, EntityMember, EntityRef, EntityRelation, EntityTypeId, EqPredicate, Expr, FieldDependency, FieldExpr, IdOf, IdSchemaOf, InPredicate, InputExpr, InputMember, LiteralExpr, NestedInput, NullPredicate, Operandish, Operation, Order, OrderTerm, Ordering, PageWindow, Placement, Predicate, Query, QueryDependencies, QueryEvaluateError, ReadFilter, Related, RelatedSpecs, Relation, RelationInput, RelationMap, RelationSpec, RelationSpecs, Row, SchemaShape, SchemaWords, Selected, Selection, SelectionPage, SelectionPageTypeId, SelectionTypeId, TargetKey, TermOptions, TextOperand, Unmapped, ValueOf, Words, Write, type WriteLink, type WriteSet, WrittenAs, WrittenKey, WrittenSpec, assertSupported, compareRows, dependenciesOf, evaluate, isPredicate, maxQueryNodes, supported };
1
+ import { $ as Words, A as SelectionPage, At as TermOptions, B as Write, C as Relation, Ct as OrderTerm, D as RelationSpecs, Dt as Predicate, E as RelationSpec, Et as Placement, F as WrittenAs, Ft as maxQueryNodes, G as Row, H as WriteSet, I as WrittenKey, It as Collation, J as decided, K as assertSupported, L as WrittenSpec, M as SelectionTypeId, Mt as ValueOf, N as TargetKey, Nt as dependenciesOf, O as Selected, Ot as Query, P as Unmapped, Pt as isPredicate, Q as SchemaWords, R as AnyWrite, S as RelatedSpecs, St as Order, T as RelationMap, Tt as Ordering, U as PredicateTruth, V as WriteLink, W as QueryEvaluateError, X as supported, Y as evaluate, Z as SchemaShape, _ as IdSchemaOf, _t as NotPredicate, a as DerivedSpecs, at as ChosenSort, b as PageWindow, bt as Operation, c as EntityDerived, ct as ContainsPredicate, d as EntityInput, dt as Expr, et as ReadFilter, f as EntityMember, ft as FieldDependency, g as IdOf, gt as LiteralExpr, h as EntityTypeId, ht as InputExpr, i as DerivedSpec, it as ChosenOrder, j as SelectionPageTypeId, jt as TextOperand, k as Selection, kt as QueryDependencies, l as EntityField, lt as Dependencies, m as EntityRelation, mt as InPredicate, n as Cardinality, nt as AnyExpr, o as Entities, ot as CompareOperator, p as EntityRef, pt as FieldExpr, q as compareRows, r as Derived, rt as AnyQuery, s as Entity, st as ComparePredicate, t as AnyEntity, tt as AndPredicate, u as EntityIdentity, ut as EqPredicate, v as InputMember, vt as NullPredicate, w as RelationInput, wt as OrderedOperand, x as Related, xt as OrPredicate, y as NestedInput, yt as Operandish, z as BoundWrite } from "./index-BzdK89FC.mjs";
2
+ export { AndPredicate, AnyEntity, AnyExpr, AnyQuery, type AnyWrite, type BoundWrite, Cardinality, ChosenOrder, ChosenSort, Collation, CompareOperator, ComparePredicate, ContainsPredicate, Dependencies, Derived, DerivedSpec, DerivedSpecs, Entities, Entity, EntityDerived, EntityField, EntityIdentity, EntityInput, EntityMember, EntityRef, EntityRelation, EntityTypeId, EqPredicate, Expr, FieldDependency, FieldExpr, IdOf, IdSchemaOf, InPredicate, InputExpr, InputMember, LiteralExpr, NestedInput, NotPredicate, NullPredicate, Operandish, Operation, OrPredicate, Order, OrderTerm, OrderedOperand, Ordering, PageWindow, Placement, Predicate, PredicateTruth, Query, QueryDependencies, QueryEvaluateError, ReadFilter, Related, RelatedSpecs, Relation, RelationInput, RelationMap, RelationSpec, RelationSpecs, Row, SchemaShape, SchemaWords, Selected, Selection, SelectionPage, SelectionPageTypeId, SelectionTypeId, TargetKey, TermOptions, TextOperand, Unmapped, ValueOf, Words, Write, type WriteLink, type WriteSet, WrittenAs, WrittenKey, WrittenSpec, assertSupported, compareRows, decided, dependenciesOf, evaluate, isPredicate, maxQueryNodes, supported };
package/dist/index.mjs CHANGED
@@ -1,2 +1 @@
1
- import { S as SchemaShape, _ as Query, a as SelectionPageTypeId, b as maxQueryNodes, c as QueryEvaluateError, d as evaluate, f as supported, g as Order, h as Expr, i as Relation, l as assertSupported, m as ReadFilter, n as Entity, o as SelectionTypeId, p as Words, r as EntityTypeId, s as Write, t as Derived, u as compareRows, v as dependenciesOf, x as Collation, y as isPredicate } from "./src-BAA6oWw-.mjs";
2
- export { Collation, Derived, Entity, EntityTypeId, Expr, Order, Query, QueryEvaluateError, ReadFilter, Relation, SchemaShape, SelectionPageTypeId, SelectionTypeId, Words, Write, assertSupported, compareRows, dependenciesOf, evaluate, isPredicate, maxQueryNodes, supported };
1
+ export { S as Collation, t as Derived, n as Entity, r as EntityTypeId, g as Expr, _ as Order, v as Query, c as QueryEvaluateError, h as ReadFilter, i as Relation, C as SchemaShape, a as SelectionPageTypeId, o as SelectionTypeId, m as Words, s as Write, l as assertSupported, u as compareRows, d as decided, y as dependenciesOf, f as evaluate, b as isPredicate, x as maxQueryNodes, p as supported } from "./src-5avJ3IkP.mjs";