@niscorp/vex 0.1.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.
- package/DESIGN.md +881 -0
- package/DOCS.md +1295 -0
- package/LICENSE +202 -0
- package/README.md +97 -0
- package/dist/adapters/express/index.cjs +1406 -0
- package/dist/adapters/express/index.cjs.map +1 -0
- package/dist/adapters/express/index.d.cts +25 -0
- package/dist/adapters/express/index.d.ts +25 -0
- package/dist/adapters/express/index.js +60 -0
- package/dist/adapters/express/index.js.map +1 -0
- package/dist/adapters/hono/index.cjs +1426 -0
- package/dist/adapters/hono/index.cjs.map +1 -0
- package/dist/adapters/hono/index.d.cts +25 -0
- package/dist/adapters/hono/index.d.ts +25 -0
- package/dist/adapters/hono/index.js +78 -0
- package/dist/adapters/hono/index.js.map +1 -0
- package/dist/adapters/pglite/index.cjs +17 -0
- package/dist/adapters/pglite/index.cjs.map +1 -0
- package/dist/adapters/pglite/index.d.cts +21 -0
- package/dist/adapters/pglite/index.d.ts +21 -0
- package/dist/adapters/pglite/index.js +14 -0
- package/dist/adapters/pglite/index.js.map +1 -0
- package/dist/agent/index.cjs +478 -0
- package/dist/agent/index.cjs.map +1 -0
- package/dist/agent/index.d.cts +29 -0
- package/dist/agent/index.d.ts +29 -0
- package/dist/agent/index.js +313 -0
- package/dist/agent/index.js.map +1 -0
- package/dist/chunk-FPKW4TRX.js +1528 -0
- package/dist/chunk-FPKW4TRX.js.map +1 -0
- package/dist/chunk-HF25Q53I.js +165 -0
- package/dist/chunk-HF25Q53I.js.map +1 -0
- package/dist/handler-Cql8SJ3F.d.cts +133 -0
- package/dist/handler-mICf9ins.d.ts +133 -0
- package/dist/index.cjs +4078 -0
- package/dist/index.cjs.map +1 -0
- package/dist/index.d.cts +199 -0
- package/dist/index.d.ts +199 -0
- package/dist/index.js +2340 -0
- package/dist/index.js.map +1 -0
- package/dist/introspect-D3OaXHBc.d.cts +16 -0
- package/dist/introspect-D3OaXHBc.d.ts +16 -0
- package/dist/types-BRvMB6IM.d.cts +1491 -0
- package/dist/types-BRvMB6IM.d.ts +1491 -0
- package/package.json +125 -0
|
@@ -0,0 +1,165 @@
|
|
|
1
|
+
import { z } from 'zod';
|
|
2
|
+
|
|
3
|
+
// src/schemas/filter.schema.ts
|
|
4
|
+
var ContextRefSchema = z.object({
|
|
5
|
+
$context: z.string().describe("Key to look up in the request context object")
|
|
6
|
+
}).strict().describe("Reference to a caller-provided context value");
|
|
7
|
+
var ScopeRefSchema = z.object({
|
|
8
|
+
$scope: z.string().describe("Key to look up in the server-side scope values")
|
|
9
|
+
}).strict().describe("Reference to a server-injected scope value (access control)");
|
|
10
|
+
var FieldOrValueSchema = z.union([
|
|
11
|
+
z.string().describe("A field path (entity.field format) or a literal string"),
|
|
12
|
+
z.number().describe("A literal number"),
|
|
13
|
+
z.boolean().describe("A literal boolean"),
|
|
14
|
+
z.null().describe("A literal null"),
|
|
15
|
+
ContextRefSchema,
|
|
16
|
+
ScopeRefSchema
|
|
17
|
+
]).describe("A field path, literal value, or dynamic reference");
|
|
18
|
+
var IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
|
|
19
|
+
var FIELD_PATH = /^[A-Za-z_][A-Za-z0-9_]*\.[A-Za-z_][A-Za-z0-9_]*$/;
|
|
20
|
+
var isIdentifier = (value) => IDENTIFIER.test(value);
|
|
21
|
+
var isFieldPathShape = (value) => typeof value === "string" && FIELD_PATH.test(value);
|
|
22
|
+
var IdentifierSchema = z.string().regex(IDENTIFIER, "A name is letters, digits and underscores, not starting with a digit");
|
|
23
|
+
var FieldPathSchema = z.string().regex(FIELD_PATH, "A field path is entity.field \u2014 each part letters, digits and underscores, not starting with a digit");
|
|
24
|
+
|
|
25
|
+
// src/schemas/filter.schema.ts
|
|
26
|
+
var comparisonPair = z.tuple([FieldOrValueSchema, FieldOrValueSchema]).describe("[left, right] \u2014 both can be field paths, literals, or references");
|
|
27
|
+
var fieldString = FieldPathSchema.describe("Field path in entity.field format");
|
|
28
|
+
var collectionTarget = z.union([
|
|
29
|
+
z.array(FieldOrValueSchema).min(1).describe("Array of literal values or references"),
|
|
30
|
+
ContextRefSchema,
|
|
31
|
+
ScopeRefSchema
|
|
32
|
+
]).describe("A set of values or a reference that resolves to an array");
|
|
33
|
+
var ExistsSchema = z.lazy(
|
|
34
|
+
() => z.object({
|
|
35
|
+
from: z.array(z.string()).min(1).describe("Entities the subquery reads. Joined by foreign key like any other from."),
|
|
36
|
+
filter: FilterSchema.optional().describe('The correlation, and any extra condition. Reference the outer query by its own entity path: { eq: ["<inner>.<fk>", "<outer>.id"] }.')
|
|
37
|
+
}).strict()
|
|
38
|
+
);
|
|
39
|
+
var FilterSchema = z.lazy(
|
|
40
|
+
() => z.union([
|
|
41
|
+
z.object({ exists: ExistsSchema }).strict().describe("EXISTS: true when the subquery matches at least one row. Wrap in `not` for NOT EXISTS."),
|
|
42
|
+
z.object({ eq: comparisonPair }).strict().describe("Equals: tests equality between two values"),
|
|
43
|
+
z.object({ neq: comparisonPair }).strict().describe("Not equals"),
|
|
44
|
+
z.object({ gt: comparisonPair }).strict().describe("Greater than"),
|
|
45
|
+
z.object({ gte: comparisonPair }).strict().describe("Greater than or equal"),
|
|
46
|
+
z.object({ lt: comparisonPair }).strict().describe("Less than"),
|
|
47
|
+
z.object({ lte: comparisonPair }).strict().describe("Less than or equal"),
|
|
48
|
+
z.object({ in: z.tuple([fieldString, collectionTarget]) }).strict().describe("Field value is in a set"),
|
|
49
|
+
z.object({ notIn: z.tuple([fieldString, collectionTarget]) }).strict().describe("Field value is not in a set"),
|
|
50
|
+
z.object({ like: z.tuple([fieldString, FieldOrValueSchema]) }).strict().describe("Case-sensitive LIKE pattern match (use % as wildcard)"),
|
|
51
|
+
z.object({ ilike: z.tuple([fieldString, FieldOrValueSchema]) }).strict().describe("Case-insensitive ILIKE pattern match (use % as wildcard)"),
|
|
52
|
+
z.object({ isNull: fieldString }).strict().describe("Field value is NULL"),
|
|
53
|
+
z.object({ isNotNull: fieldString }).strict().describe("Field value is NOT NULL"),
|
|
54
|
+
z.object({ and: z.array(FilterSchema).min(2) }).strict().describe("Logical AND: all conditions must be true"),
|
|
55
|
+
z.object({ or: z.array(FilterSchema).min(2) }).strict().describe("Logical OR: at least one condition must be true"),
|
|
56
|
+
z.object({ not: FilterSchema }).strict().describe("Logical NOT: negates the condition"),
|
|
57
|
+
z.object({
|
|
58
|
+
semantic: z.object({
|
|
59
|
+
field: FieldPathSchema.describe("Vector column field path (entity.field)"),
|
|
60
|
+
query: z.union([ContextRefSchema, ScopeRefSchema]).describe("Text to embed and compare"),
|
|
61
|
+
minScore: z.number().min(0).max(1).optional().describe("Minimum cosine similarity (0\u20131)")
|
|
62
|
+
}).strict()
|
|
63
|
+
}).strict().describe("Semantic vector similarity search"),
|
|
64
|
+
z.object({
|
|
65
|
+
fuzzy: z.object({
|
|
66
|
+
field: FieldPathSchema.describe("String field path"),
|
|
67
|
+
query: z.union([ContextRefSchema, ScopeRefSchema]).describe("Text to fuzzy-match"),
|
|
68
|
+
maxDistance: z.number().int().nonnegative().optional().describe("Maximum Levenshtein edit distance")
|
|
69
|
+
}).strict()
|
|
70
|
+
}).strict().describe("Fuzzy string match"),
|
|
71
|
+
z.object({
|
|
72
|
+
optional: z.object({
|
|
73
|
+
key: z.union([z.string().min(1), z.array(z.string().min(1)).min(1)]).describe("The context key this condition depends on, or EVERY key it depends on. A condition referencing two keys must name both \u2014 gating on one leaves the other conditionally required, which surfaces as an empty result rather than as a condition that did not apply."),
|
|
74
|
+
// BARE, never `.describe()`d. That call CLONES the schema, and zod
|
|
75
|
+
// detects a recursive reference by instance identity — a clone is a
|
|
76
|
+
// different instance, so `to-json-schema` stops seeing the cycle and
|
|
77
|
+
// expands the filter union into itself until the stack goes. Every
|
|
78
|
+
// other recursive slot here (`not`, `and`, `or`) uses it bare for the
|
|
79
|
+
// same reason; the description belongs on the wrapper below.
|
|
80
|
+
then: FilterSchema
|
|
81
|
+
}).strict()
|
|
82
|
+
}).strict().describe(
|
|
83
|
+
'A condition the caller turns on by supplying context keys. When any named key is absent the condition is REMOVED from the query before it compiles \u2014 it does not match everything, it is not there. Absent means missing, undefined or null; "" is a value and keeps the condition. Direction follows position: under `and` supplying the key NARROWS, under `or` it WIDENS. Either way an absent key reads exactly as if the condition had never been written, and scope is injected afterwards regardless. Reads only: a mutation may not contain one, and neither may the inside of an `exists` (its correlation must be unconditional).'
|
|
84
|
+
)
|
|
85
|
+
])
|
|
86
|
+
);
|
|
87
|
+
var CaseWhenSchema = z.object({
|
|
88
|
+
condition: FilterSchema,
|
|
89
|
+
then: FieldOrValueSchema.describe("Value when condition is true")
|
|
90
|
+
}).strict();
|
|
91
|
+
var ComputeExpressionSchema = z.union([
|
|
92
|
+
z.object({ add: z.tuple([FieldOrValueSchema, FieldOrValueSchema]) }).strict().describe("Addition: a + b"),
|
|
93
|
+
z.object({ subtract: z.tuple([FieldOrValueSchema, FieldOrValueSchema]) }).strict().describe("Subtraction: a - b"),
|
|
94
|
+
z.object({ multiply: z.tuple([FieldOrValueSchema, FieldOrValueSchema]) }).strict().describe("Multiplication: a * b"),
|
|
95
|
+
z.object({ divide: z.tuple([FieldOrValueSchema, FieldOrValueSchema]) }).strict().describe("Division: a / b"),
|
|
96
|
+
z.object({ concat: z.array(FieldOrValueSchema).min(2) }).strict().describe("String concatenation"),
|
|
97
|
+
z.object({ coalesce: z.array(FieldOrValueSchema).min(2) }).strict().describe("Returns first non-null value"),
|
|
98
|
+
z.object({
|
|
99
|
+
case: z.object({
|
|
100
|
+
when: z.array(CaseWhenSchema).min(1).describe("Condition/result pairs evaluated in order"),
|
|
101
|
+
else: FieldOrValueSchema.describe("Default value when no condition matches")
|
|
102
|
+
}).strict()
|
|
103
|
+
}).strict().describe("CASE WHEN conditional expression")
|
|
104
|
+
]).describe("Computed expression: arithmetic, string, or conditional");
|
|
105
|
+
var fieldPath = FieldPathSchema.describe("Field path in entity.field format");
|
|
106
|
+
var fieldOrExpr = z.union([fieldPath, ComputeExpressionSchema]).describe("A field path or a compute expression");
|
|
107
|
+
var AggregateExpressionSchema = z.union([
|
|
108
|
+
z.object({ count: z.union([FieldPathSchema, z.literal("*")]).describe('Field path or "*" for COUNT(*)') }).strict().describe("COUNT"),
|
|
109
|
+
z.object({ countDistinct: FieldPathSchema.describe("Field path whose distinct non-null values are counted") }).strict().describe("COUNT(DISTINCT field)"),
|
|
110
|
+
z.object({ sum: fieldOrExpr }).strict().describe("SUM"),
|
|
111
|
+
z.object({ avg: fieldOrExpr }).strict().describe("AVG"),
|
|
112
|
+
z.object({ min: fieldOrExpr }).strict().describe("MIN"),
|
|
113
|
+
z.object({ max: fieldOrExpr }).strict().describe("MAX")
|
|
114
|
+
]).describe("Aggregate function applied to a field or expression");
|
|
115
|
+
var SortEntrySchema = z.object({
|
|
116
|
+
field: z.union([FieldPathSchema, IdentifierSchema]).describe("Field path (entity.field), computed field name, or aggregate alias"),
|
|
117
|
+
dir: z.enum(["asc", "desc"]).default("asc").describe("Sort direction")
|
|
118
|
+
}).strict().describe("Sort specification");
|
|
119
|
+
var SubquerySourceSchema = z.object({
|
|
120
|
+
as: IdentifierSchema.describe("Alias for subquery results \u2014 use as prefix in field paths"),
|
|
121
|
+
query: z.lazy(() => QuerySchema).describe("A nested query")
|
|
122
|
+
}).strict().describe("Subquery data source: a nested query read as a table under `as`, its columns referenced as `<as>.<field>` anywhere in the outer query. Joined by foreign key like an entity when one links them; otherwise every outer row is paired with every subquery row (a cross join), so a one-row subquery puts its values beside each outer row.");
|
|
123
|
+
var SourceSchema = z.union([
|
|
124
|
+
z.string().describe("Entity name from the database schema"),
|
|
125
|
+
SubquerySourceSchema
|
|
126
|
+
]).describe("Data source: entity name or subquery");
|
|
127
|
+
var FieldRefSchema = z.union([
|
|
128
|
+
FieldPathSchema.describe("A column in entity.field format"),
|
|
129
|
+
z.object({
|
|
130
|
+
field: FieldPathSchema.describe("A column in entity.field format"),
|
|
131
|
+
as: IdentifierSchema.describe("Output key for this column")
|
|
132
|
+
}).strict().describe("An aliased column: output under `as` instead of the column name")
|
|
133
|
+
]).describe("A selected field \u2014 a bare `entity.field`, or `{ field, as }` to alias the output key");
|
|
134
|
+
var QuerySchema = z.lazy(
|
|
135
|
+
() => z.object({
|
|
136
|
+
from: z.array(SourceSchema).min(1).describe("Data sources \u2014 entity names or subqueries. Every entity used anywhere in the query must be listed here. Listed entities are JOINED FOR YOU along their foreign keys \u2014 a nullable key as a LEFT JOIN, so a row whose key is empty is kept, with the joined columns null. Never restate a join as a filter comparing the two keys: that throws those rows away."),
|
|
137
|
+
fields: z.array(FieldRefSchema).optional().describe("Raw columns to select \u2014 each `entity.field`, or `{ field, as }` to alias the output key (no SELECT *). Optional: omit it for an aggregate-only query (e.g. a bare COUNT). Do not list compute or aggregate aliases here \u2014 those are added automatically."),
|
|
138
|
+
filter: FilterSchema.optional().describe("Filter conditions"),
|
|
139
|
+
compute: z.record(IdentifierSchema, ComputeExpressionSchema).optional().describe("Computed fields \u2014 key is output alias, value is the expression"),
|
|
140
|
+
aggregate: z.record(IdentifierSchema, AggregateExpressionSchema).optional().describe("Aggregate functions \u2014 key is output alias, value is the function"),
|
|
141
|
+
groupBy: z.array(FieldPathSchema).optional().describe("Fields to group by for aggregation"),
|
|
142
|
+
sort: z.array(SortEntrySchema).optional().describe("Sort order"),
|
|
143
|
+
limit: z.number().int().positive().optional().describe("Maximum rows to return"),
|
|
144
|
+
distinct: z.boolean().optional().describe("Eliminate duplicate rows")
|
|
145
|
+
}).strict().refine(
|
|
146
|
+
(q) => (q.fields?.length ?? 0) > 0 || Object.keys(q.aggregate ?? {}).length > 0,
|
|
147
|
+
{ message: "A query must select at least one of `fields` or `aggregate`." }
|
|
148
|
+
)
|
|
149
|
+
);
|
|
150
|
+
|
|
151
|
+
// src/errors.ts
|
|
152
|
+
var VexError = class extends Error {
|
|
153
|
+
code;
|
|
154
|
+
details;
|
|
155
|
+
constructor(code, message, details) {
|
|
156
|
+
super(message);
|
|
157
|
+
this.name = "VexError";
|
|
158
|
+
this.code = code;
|
|
159
|
+
this.details = details;
|
|
160
|
+
}
|
|
161
|
+
};
|
|
162
|
+
|
|
163
|
+
export { AggregateExpressionSchema, ComputeExpressionSchema, FilterSchema, QuerySchema, VexError, isFieldPathShape, isIdentifier };
|
|
164
|
+
//# sourceMappingURL=chunk-HF25Q53I.js.map
|
|
165
|
+
//# sourceMappingURL=chunk-HF25Q53I.js.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"sources":["../src/schemas/value.schema.ts","../src/schemas/identifier.schema.ts","../src/schemas/filter.schema.ts","../src/schemas/compute.schema.ts","../src/schemas/aggregate.schema.ts","../src/schemas/query.schema.ts","../src/errors.ts"],"names":["z"],"mappings":"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","file":"chunk-HF25Q53I.js","sourcesContent":["import { z } from 'zod';\n\nexport const ContextRefSchema = z\n .object({\n $context: z.string().describe('Key to look up in the request context object'),\n })\n .strict()\n .describe('Reference to a caller-provided context value');\n\nexport const ScopeRefSchema = z\n .object({\n $scope: z.string().describe('Key to look up in the server-side scope values'),\n })\n .strict()\n .describe('Reference to a server-injected scope value (access control)');\n\nexport const FieldOrValueSchema = z\n .union([\n z.string().describe('A field path (entity.field format) or a literal string'),\n z.number().describe('A literal number'),\n z.boolean().describe('A literal boolean'),\n z.null().describe('A literal null'),\n ContextRefSchema,\n ScopeRefSchema,\n ])\n .describe('A field path, literal value, or dynamic reference');\n\nexport type ContextRef = z.infer<typeof ContextRefSchema>;\nexport type ScopeRef = z.infer<typeof ScopeRefSchema>;\nexport type FieldOrValue = z.infer<typeof FieldOrValueSchema>;\n","import { z } from 'zod';\n\n// ═══════════════════════════════════════════════════════════════\n// THE NAMES A QUERY MAY SAY — and the one rule for telling them apart.\n//\n// Every string an author (a person, a seed, a model) puts in a NAME position\n// ends up in SQL text: a column reference, an output alias, a subquery alias.\n// Values never do — they bind as parameters or are quoted as literals. So a\n// name is the only place authored text meets the statement, and it is held to\n// a grammar that cannot carry anything but a name: letters, digits and\n// underscores, not starting with a digit.\n//\n// This is the parse-time half. The resolver checks the same predicates again,\n// because `engine.compile()` and `engine.test()` take a DSL that never went\n// through Zod, and the compiler refuses to emit a field position that did not\n// resolve against the introspected schema. Three layers, one grammar.\n//\n// `isFieldPathShape` is also what decides, in a value position, whether a\n// string is a column or a literal. It used to be \"contains a dot\", which made\n// every email address an unknown entity and every string with a dot a column\n// reference — so a literal like \"u1@x.com\" threw, and a string that merely\n// looked dotted went to SQL as a name. Now a column is exactly `ident.ident`,\n// and everything else is a literal.\n// ═══════════════════════════════════════════════════════════════\n\nconst IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;\nconst FIELD_PATH = /^[A-Za-z_][A-Za-z0-9_]*\\.[A-Za-z_][A-Za-z0-9_]*$/;\n\nexport const isIdentifier = (value: string): boolean => IDENTIFIER.test(value);\n\nexport const isFieldPathShape = (value: unknown): value is string => typeof value === 'string' && FIELD_PATH.test(value);\n\nexport const IdentifierSchema = z\n .string()\n .regex(IDENTIFIER, 'A name is letters, digits and underscores, not starting with a digit');\n\nexport const FieldPathSchema = z\n .string()\n .regex(FIELD_PATH, 'A field path is entity.field — each part letters, digits and underscores, not starting with a digit');\n","import { z } from 'zod';\nimport { ContextRefSchema, ScopeRefSchema, FieldOrValueSchema } from './value.schema.js';\nimport { FieldPathSchema } from './identifier.schema.js';\nimport type { ContextRef, ScopeRef, FieldOrValue } from './value.schema.js';\n\n// EXISTS — \"is there a row over there that points back at this one\".\n//\n// It is the same `{ from, filter }` a query already is, and deliberately no\n// more than that: no fields, no sort, no limit, nothing to select. EXISTS asks\n// whether a row is there, so anything that shapes output would be noise the\n// planner discards, and refusing it is what keeps this an operator rather than\n// an invitation to nest arbitrary SQL.\n//\n// The CORRELATION needs no new vocabulary. A dotted string on either side of a\n// comparison is already a field path, so pointing the inner table at the outer\n// one is an ordinary `eq` between two columns:\n//\n// { exists: { from: ['tasks'], filter: { eq: ['tasks.issue_id', 'issues.id'] } } }\n//\n// and `not` composes for NOT EXISTS. Whoever writes SQL writes this on the\n// first try, which is the entire design goal.\nexport type ExistsQuery = {\n from: string[];\n filter?: Filter;\n};\n\nexport type Filter =\n | { exists: ExistsQuery }\n | { eq: [FieldOrValue, FieldOrValue] }\n | { neq: [FieldOrValue, FieldOrValue] }\n | { gt: [FieldOrValue, FieldOrValue] }\n | { gte: [FieldOrValue, FieldOrValue] }\n | { lt: [FieldOrValue, FieldOrValue] }\n | { lte: [FieldOrValue, FieldOrValue] }\n | { in: [string, FieldOrValue[] | ContextRef | ScopeRef] }\n | { notIn: [string, FieldOrValue[] | ContextRef | ScopeRef] }\n | { like: [string, FieldOrValue] }\n | { ilike: [string, FieldOrValue] }\n | { isNull: string }\n | { isNotNull: string }\n | { and: Filter[] }\n | { or: Filter[] }\n | { not: Filter }\n | { semantic: { field: string; query: ContextRef | ScopeRef; minScore?: number } }\n | { fuzzy: { field: string; query: ContextRef | ScopeRef; maxDistance?: number } }\n | { optional: { key: string | string[]; then: Filter } };\n\nconst comparisonPair = z\n .tuple([FieldOrValueSchema, FieldOrValueSchema])\n .describe('[left, right] — both can be field paths, literals, or references');\n\nconst fieldString = FieldPathSchema.describe('Field path in entity.field format');\n\nconst collectionTarget = z\n .union([\n z.array(FieldOrValueSchema).min(1).describe('Array of literal values or references'),\n ContextRefSchema,\n ScopeRefSchema,\n ])\n .describe('A set of values or a reference that resolves to an array');\n\nconst ExistsSchema: z.ZodType<ExistsQuery> = z.lazy(() =>\n z\n .object({\n from: z.array(z.string()).min(1).describe('Entities the subquery reads. Joined by foreign key like any other from.'),\n filter: FilterSchema.optional().describe('The correlation, and any extra condition. Reference the outer query by its own entity path: { eq: [\"<inner>.<fk>\", \"<outer>.id\"] }.'),\n })\n .strict(),\n);\n\nexport const FilterSchema: z.ZodType<Filter> = z.lazy(() =>\n z.union([\n z.object({ exists: ExistsSchema }).strict().describe('EXISTS: true when the subquery matches at least one row. Wrap in `not` for NOT EXISTS.'),\n z.object({ eq: comparisonPair }).strict().describe('Equals: tests equality between two values'),\n z.object({ neq: comparisonPair }).strict().describe('Not equals'),\n z.object({ gt: comparisonPair }).strict().describe('Greater than'),\n z.object({ gte: comparisonPair }).strict().describe('Greater than or equal'),\n z.object({ lt: comparisonPair }).strict().describe('Less than'),\n z.object({ lte: comparisonPair }).strict().describe('Less than or equal'),\n z.object({ in: z.tuple([fieldString, collectionTarget]) }).strict().describe('Field value is in a set'),\n z.object({ notIn: z.tuple([fieldString, collectionTarget]) }).strict().describe('Field value is not in a set'),\n z.object({ like: z.tuple([fieldString, FieldOrValueSchema]) }).strict().describe('Case-sensitive LIKE pattern match (use % as wildcard)'),\n z.object({ ilike: z.tuple([fieldString, FieldOrValueSchema]) }).strict().describe('Case-insensitive ILIKE pattern match (use % as wildcard)'),\n z.object({ isNull: fieldString }).strict().describe('Field value is NULL'),\n z.object({ isNotNull: fieldString }).strict().describe('Field value is NOT NULL'),\n z.object({ and: z.array(FilterSchema).min(2) }).strict().describe('Logical AND: all conditions must be true'),\n z.object({ or: z.array(FilterSchema).min(2) }).strict().describe('Logical OR: at least one condition must be true'),\n z.object({ not: FilterSchema }).strict().describe('Logical NOT: negates the condition'),\n z.object({\n semantic: z.object({\n field: FieldPathSchema.describe('Vector column field path (entity.field)'),\n query: z.union([ContextRefSchema, ScopeRefSchema]).describe('Text to embed and compare'),\n minScore: z.number().min(0).max(1).optional().describe('Minimum cosine similarity (0–1)'),\n }).strict(),\n }).strict().describe('Semantic vector similarity search'),\n z.object({\n fuzzy: z.object({\n field: FieldPathSchema.describe('String field path'),\n query: z.union([ContextRefSchema, ScopeRefSchema]).describe('Text to fuzzy-match'),\n maxDistance: z.number().int().nonnegative().optional().describe('Maximum Levenshtein edit distance'),\n }).strict(),\n }).strict().describe('Fuzzy string match'),\n z.object({\n optional: z.object({\n key: z.union([z.string().min(1), z.array(z.string().min(1)).min(1)])\n .describe('The context key this condition depends on, or EVERY key it depends on. A condition referencing two keys must name both — gating on one leaves the other conditionally required, which surfaces as an empty result rather than as a condition that did not apply.'),\n // BARE, never `.describe()`d. That call CLONES the schema, and zod\n // detects a recursive reference by instance identity — a clone is a\n // different instance, so `to-json-schema` stops seeing the cycle and\n // expands the filter union into itself until the stack goes. Every\n // other recursive slot here (`not`, `and`, `or`) uses it bare for the\n // same reason; the description belongs on the wrapper below.\n then: FilterSchema,\n }).strict(),\n }).strict().describe(\n 'A condition the caller turns on by supplying context keys. When any named key is absent the condition is REMOVED from the query before it compiles — it does not match everything, it is not there. Absent means missing, undefined or null; \"\" is a value and keeps the condition. Direction follows position: under `and` supplying the key NARROWS, under `or` it WIDENS. Either way an absent key reads exactly as if the condition had never been written, and scope is injected afterwards regardless. Reads only: a mutation may not contain one, and neither may the inside of an `exists` (its correlation must be unconditional).',\n ),\n ]),\n);\n","import { z } from 'zod';\nimport { FieldOrValueSchema } from './value.schema.js';\nimport { FilterSchema } from './filter.schema.js';\n\nconst CaseWhenSchema = z\n .object({\n condition: FilterSchema,\n then: FieldOrValueSchema.describe('Value when condition is true'),\n })\n .strict();\n\nexport const ComputeExpressionSchema = z\n .union([\n z.object({ add: z.tuple([FieldOrValueSchema, FieldOrValueSchema]) }).strict().describe('Addition: a + b'),\n z.object({ subtract: z.tuple([FieldOrValueSchema, FieldOrValueSchema]) }).strict().describe('Subtraction: a - b'),\n z.object({ multiply: z.tuple([FieldOrValueSchema, FieldOrValueSchema]) }).strict().describe('Multiplication: a * b'),\n z.object({ divide: z.tuple([FieldOrValueSchema, FieldOrValueSchema]) }).strict().describe('Division: a / b'),\n z.object({ concat: z.array(FieldOrValueSchema).min(2) }).strict().describe('String concatenation'),\n z.object({ coalesce: z.array(FieldOrValueSchema).min(2) }).strict().describe('Returns first non-null value'),\n z.object({\n case: z\n .object({\n when: z.array(CaseWhenSchema).min(1).describe('Condition/result pairs evaluated in order'),\n else: FieldOrValueSchema.describe('Default value when no condition matches'),\n })\n .strict(),\n }).strict().describe('CASE WHEN conditional expression'),\n ])\n .describe('Computed expression: arithmetic, string, or conditional');\n\nexport type ComputeExpression = z.infer<typeof ComputeExpressionSchema>;\n","import { z } from 'zod';\nimport { ComputeExpressionSchema } from './compute.schema.js';\nimport { FieldPathSchema } from './identifier.schema.js';\n\nconst fieldPath = FieldPathSchema.describe('Field path in entity.field format');\n\n// SUM/AVG/MIN/MAX take either a field path or a compute expression — so the\n// argument can be a derived value (e.g. SUM(value * win_probability / 100)),\n// not just a column. A bare string stays valid (non-breaking).\nconst fieldOrExpr = z.union([fieldPath, ComputeExpressionSchema]).describe('A field path or a compute expression');\n\nexport const AggregateExpressionSchema = z\n .union([\n z.object({ count: z.union([FieldPathSchema, z.literal('*')]).describe('Field path or \"*\" for COUNT(*)') }).strict().describe('COUNT'),\n z.object({ countDistinct: FieldPathSchema.describe('Field path whose distinct non-null values are counted') }).strict().describe('COUNT(DISTINCT field)'),\n z.object({ sum: fieldOrExpr }).strict().describe('SUM'),\n z.object({ avg: fieldOrExpr }).strict().describe('AVG'),\n z.object({ min: fieldOrExpr }).strict().describe('MIN'),\n z.object({ max: fieldOrExpr }).strict().describe('MAX'),\n ])\n .describe('Aggregate function applied to a field or expression');\n\nexport type AggregateExpression = z.infer<typeof AggregateExpressionSchema>;\n","import { z } from 'zod';\nimport { FilterSchema } from './filter.schema.js';\nimport { ComputeExpressionSchema } from './compute.schema.js';\nimport { AggregateExpressionSchema } from './aggregate.schema.js';\nimport { FieldPathSchema, IdentifierSchema } from './identifier.schema.js';\nimport type { Filter } from './filter.schema.js';\nimport type { ComputeExpression } from './compute.schema.js';\nimport type { AggregateExpression } from './aggregate.schema.js';\n\nexport const SortEntrySchema = z\n .object({\n field: z.union([FieldPathSchema, IdentifierSchema]).describe('Field path (entity.field), computed field name, or aggregate alias'),\n dir: z.enum(['asc', 'desc']).default('asc').describe('Sort direction'),\n })\n .strict()\n .describe('Sort specification');\n\nexport type SortEntry = z.infer<typeof SortEntrySchema>;\n\nexport type Source = string | { as: string; query: Query };\n\n// A selected field: a bare `entity.field` path, or an aliased one whose output\n// key is `as` (so joined columns that would collide — three `name`s — get\n// distinct keys without a compute hack).\nexport type FieldRef = string | { field: string; as: string };\n\nexport type Query = {\n from: Source[];\n // Optional: a query may select only aggregates (e.g. a bare `COUNT(*)`); the\n // schema requires at least one of `fields` / `aggregate`.\n fields?: FieldRef[];\n filter?: Filter;\n compute?: Record<string, ComputeExpression>;\n aggregate?: Record<string, AggregateExpression>;\n groupBy?: string[];\n sort?: SortEntry[];\n limit?: number;\n distinct?: boolean;\n};\n\nconst SubquerySourceSchema = z\n .object({\n as: IdentifierSchema.describe('Alias for subquery results — use as prefix in field paths'),\n query: z.lazy((): z.ZodType<Query> => QuerySchema).describe('A nested query'),\n })\n .strict()\n .describe('Subquery data source: a nested query read as a table under `as`, its columns referenced as `<as>.<field>` anywhere in the outer query. Joined by foreign key like an entity when one links them; otherwise every outer row is paired with every subquery row (a cross join), so a one-row subquery puts its values beside each outer row.');\n\nconst SourceSchema = z\n .union([\n z.string().describe('Entity name from the database schema'),\n SubquerySourceSchema,\n ])\n .describe('Data source: entity name or subquery');\n\nconst FieldRefSchema = z\n .union([\n FieldPathSchema.describe('A column in entity.field format'),\n z\n .object({\n field: FieldPathSchema.describe('A column in entity.field format'),\n as: IdentifierSchema.describe('Output key for this column'),\n })\n .strict()\n .describe('An aliased column: output under `as` instead of the column name'),\n ])\n .describe('A selected field — a bare `entity.field`, or `{ field, as }` to alias the output key');\n\nexport const QuerySchema: z.ZodType<Query> = z.lazy(() =>\n z\n .object({\n from: z.array(SourceSchema).min(1).describe('Data sources — entity names or subqueries. Every entity used anywhere in the query must be listed here. Listed entities are JOINED FOR YOU along their foreign keys — a nullable key as a LEFT JOIN, so a row whose key is empty is kept, with the joined columns null. Never restate a join as a filter comparing the two keys: that throws those rows away.'),\n fields: z.array(FieldRefSchema).optional().describe('Raw columns to select — each `entity.field`, or `{ field, as }` to alias the output key (no SELECT *). Optional: omit it for an aggregate-only query (e.g. a bare COUNT). Do not list compute or aggregate aliases here — those are added automatically.'),\n filter: FilterSchema.optional().describe('Filter conditions'),\n compute: z.record(IdentifierSchema, ComputeExpressionSchema).optional().describe('Computed fields — key is output alias, value is the expression'),\n aggregate: z.record(IdentifierSchema, AggregateExpressionSchema).optional().describe('Aggregate functions — key is output alias, value is the function'),\n groupBy: z.array(FieldPathSchema).optional().describe('Fields to group by for aggregation'),\n sort: z.array(SortEntrySchema).optional().describe('Sort order'),\n limit: z.number().int().positive().optional().describe('Maximum rows to return'),\n distinct: z.boolean().optional().describe('Eliminate duplicate rows'),\n })\n .strict()\n .refine(\n (q) => (q.fields?.length ?? 0) > 0 || Object.keys(q.aggregate ?? {}).length > 0,\n { message: 'A query must select at least one of `fields` or `aggregate`.' },\n ),\n);\n\nexport { SubquerySourceSchema, SourceSchema };\n","import type { QueryErrorCode } from './schemas/request.schema.js';\n\nexport class VexError extends Error {\n readonly code: QueryErrorCode;\n readonly details?: Record<string, unknown>;\n\n constructor(code: QueryErrorCode, message: string, details?: Record<string, unknown>) {\n super(message);\n this.name = 'VexError';\n this.code = code;\n this.details = details;\n }\n}\n"]}
|
|
@@ -0,0 +1,133 @@
|
|
|
1
|
+
import { ak as ScopeValues, S as ScopePolicy, D as DatabaseSchema, f as Row, M as MutationDefinition, N as Mutation, b as Query, u as CoreMutation, a as QueryEngine, a0 as QueryResponse } from './types-BRvMB6IM.cjs';
|
|
2
|
+
|
|
3
|
+
type MutationTx = {
|
|
4
|
+
query: (sql: string, params?: unknown[]) => Promise<{
|
|
5
|
+
rows: unknown[];
|
|
6
|
+
}>;
|
|
7
|
+
};
|
|
8
|
+
type MutationClient = MutationTx & {
|
|
9
|
+
transaction?: <T>(fn: (tx: MutationTx) => Promise<T>) => Promise<T>;
|
|
10
|
+
};
|
|
11
|
+
type MutationContext = {
|
|
12
|
+
context: Record<string, unknown>;
|
|
13
|
+
scope: ScopeValues;
|
|
14
|
+
policy: ScopePolicy;
|
|
15
|
+
schema: DatabaseSchema;
|
|
16
|
+
};
|
|
17
|
+
type WriteResult = {
|
|
18
|
+
table: string;
|
|
19
|
+
op: 'insert' | 'update' | 'delete';
|
|
20
|
+
rows: Row[];
|
|
21
|
+
};
|
|
22
|
+
declare const executeWrites: (client: MutationClient, def: MutationDefinition, mctx: MutationContext) => Promise<WriteResult[]>;
|
|
23
|
+
declare const executeMutation: (client: MutationClient, def: MutationDefinition, mctx: MutationContext) => Promise<Row[]>;
|
|
24
|
+
|
|
25
|
+
type ContextField = {
|
|
26
|
+
type: string;
|
|
27
|
+
column?: string;
|
|
28
|
+
note?: string;
|
|
29
|
+
};
|
|
30
|
+
type ContextSignature = Record<string, ContextField>;
|
|
31
|
+
type MutationEffect = {
|
|
32
|
+
op: Mutation['op'];
|
|
33
|
+
table: string;
|
|
34
|
+
columns: string[];
|
|
35
|
+
};
|
|
36
|
+
declare const collectMutationContext: (def: MutationDefinition, schema?: DatabaseSchema) => ContextSignature;
|
|
37
|
+
declare const collectQueryContext: (dsl: Query, schema?: DatabaseSchema) => ContextSignature;
|
|
38
|
+
declare const mutationEffect: (def: MutationDefinition) => MutationEffect[];
|
|
39
|
+
declare const requiredContextKeys: (m: CoreMutation) => string[];
|
|
40
|
+
declare const lintMutation: (def: MutationDefinition) => string[];
|
|
41
|
+
|
|
42
|
+
type VexHandlerConfig = {
|
|
43
|
+
engine: QueryEngine;
|
|
44
|
+
entities?: string[];
|
|
45
|
+
locked?: boolean;
|
|
46
|
+
scopePolicy?: ScopePolicy;
|
|
47
|
+
policyForReach?: (reach: string) => Promise<ScopePolicy | undefined> | ScopePolicy | undefined;
|
|
48
|
+
mutations?: {
|
|
49
|
+
client: MutationClient;
|
|
50
|
+
policy: ScopePolicy;
|
|
51
|
+
onWrite?: (event: WriteEvent) => void;
|
|
52
|
+
};
|
|
53
|
+
onExecute?: (record: ExecuteRecord) => void;
|
|
54
|
+
};
|
|
55
|
+
type WriteEvent = {
|
|
56
|
+
fingerprint: string;
|
|
57
|
+
writes: WriteResult[];
|
|
58
|
+
scope: ScopeValues;
|
|
59
|
+
};
|
|
60
|
+
type VexLive = {
|
|
61
|
+
signal: AbortSignal;
|
|
62
|
+
onChange: (response: QueryResponse) => void;
|
|
63
|
+
};
|
|
64
|
+
declare const tablesChangedBy: (writes: readonly WriteResult[], schema: DatabaseSchema | undefined) => string[];
|
|
65
|
+
type ExecuteRecord = {
|
|
66
|
+
kind: 'query' | 'mutation';
|
|
67
|
+
status: 'ok' | 'error' | 'refused';
|
|
68
|
+
fingerprint?: string;
|
|
69
|
+
reach?: string;
|
|
70
|
+
cacheHit?: boolean;
|
|
71
|
+
rows?: number;
|
|
72
|
+
startUnixNano: number;
|
|
73
|
+
endUnixNano: number;
|
|
74
|
+
scope: ScopeValues;
|
|
75
|
+
};
|
|
76
|
+
type DiscoveryFingerprint = {
|
|
77
|
+
fingerprint: string;
|
|
78
|
+
kind: 'query' | 'mutation';
|
|
79
|
+
protected: boolean;
|
|
80
|
+
schemaFresh: boolean;
|
|
81
|
+
intent?: string;
|
|
82
|
+
createdAt: number;
|
|
83
|
+
lastUsedAt?: number;
|
|
84
|
+
context?: ContextSignature;
|
|
85
|
+
shape?: unknown;
|
|
86
|
+
effect?: MutationEffect[];
|
|
87
|
+
};
|
|
88
|
+
type DiscoveryResponse = {
|
|
89
|
+
vex: string;
|
|
90
|
+
description: string;
|
|
91
|
+
entities: DiscoveryEntity[];
|
|
92
|
+
protection: 'all' | 'some' | 'none';
|
|
93
|
+
locked: boolean;
|
|
94
|
+
fingerprints: DiscoveryFingerprint[];
|
|
95
|
+
query: {
|
|
96
|
+
method: string;
|
|
97
|
+
accepts: string;
|
|
98
|
+
body: Record<string, DiscoveryField>;
|
|
99
|
+
};
|
|
100
|
+
dsl: object;
|
|
101
|
+
};
|
|
102
|
+
type DiscoveryEntity = {
|
|
103
|
+
name: string;
|
|
104
|
+
fields: Array<{
|
|
105
|
+
name: string;
|
|
106
|
+
type: string;
|
|
107
|
+
nullable: boolean;
|
|
108
|
+
primaryKey: boolean;
|
|
109
|
+
}>;
|
|
110
|
+
relations: Array<{
|
|
111
|
+
entity: string;
|
|
112
|
+
type: string;
|
|
113
|
+
via: string[];
|
|
114
|
+
}>;
|
|
115
|
+
rowCount?: number;
|
|
116
|
+
};
|
|
117
|
+
type DiscoveryField = {
|
|
118
|
+
type: string;
|
|
119
|
+
required: boolean;
|
|
120
|
+
description: string;
|
|
121
|
+
};
|
|
122
|
+
declare const handleDiscovery: (config: VexHandlerConfig) => Promise<DiscoveryResponse>;
|
|
123
|
+
type QueryResult = {
|
|
124
|
+
status: number;
|
|
125
|
+
body: unknown;
|
|
126
|
+
};
|
|
127
|
+
declare const handleQuery: (config: VexHandlerConfig, body: unknown, scope: ScopeValues, live?: VexLive) => Promise<QueryResult>;
|
|
128
|
+
declare const handleFingerprintPatch: (config: VexHandlerConfig, fingerprint: string, patch: {
|
|
129
|
+
protected?: boolean;
|
|
130
|
+
}) => Promise<QueryResult>;
|
|
131
|
+
declare const handleFingerprintDelete: (config: VexHandlerConfig, fingerprint: string) => Promise<QueryResult>;
|
|
132
|
+
|
|
133
|
+
export { type ContextField as C, type DiscoveryFingerprint as D, type ExecuteRecord as E, type MutationClient as M, type QueryResult as Q, type VexHandlerConfig as V, type WriteEvent as W, type ContextSignature as a, type DiscoveryResponse as b, type MutationContext as c, type MutationEffect as d, type MutationTx as e, type VexLive as f, type WriteResult as g, collectMutationContext as h, collectQueryContext as i, executeMutation as j, executeWrites as k, handleDiscovery as l, handleFingerprintDelete as m, handleFingerprintPatch as n, handleQuery as o, lintMutation as p, mutationEffect as q, requiredContextKeys as r, tablesChangedBy as t };
|
|
@@ -0,0 +1,133 @@
|
|
|
1
|
+
import { ak as ScopeValues, S as ScopePolicy, D as DatabaseSchema, f as Row, M as MutationDefinition, N as Mutation, b as Query, u as CoreMutation, a as QueryEngine, a0 as QueryResponse } from './types-BRvMB6IM.js';
|
|
2
|
+
|
|
3
|
+
type MutationTx = {
|
|
4
|
+
query: (sql: string, params?: unknown[]) => Promise<{
|
|
5
|
+
rows: unknown[];
|
|
6
|
+
}>;
|
|
7
|
+
};
|
|
8
|
+
type MutationClient = MutationTx & {
|
|
9
|
+
transaction?: <T>(fn: (tx: MutationTx) => Promise<T>) => Promise<T>;
|
|
10
|
+
};
|
|
11
|
+
type MutationContext = {
|
|
12
|
+
context: Record<string, unknown>;
|
|
13
|
+
scope: ScopeValues;
|
|
14
|
+
policy: ScopePolicy;
|
|
15
|
+
schema: DatabaseSchema;
|
|
16
|
+
};
|
|
17
|
+
type WriteResult = {
|
|
18
|
+
table: string;
|
|
19
|
+
op: 'insert' | 'update' | 'delete';
|
|
20
|
+
rows: Row[];
|
|
21
|
+
};
|
|
22
|
+
declare const executeWrites: (client: MutationClient, def: MutationDefinition, mctx: MutationContext) => Promise<WriteResult[]>;
|
|
23
|
+
declare const executeMutation: (client: MutationClient, def: MutationDefinition, mctx: MutationContext) => Promise<Row[]>;
|
|
24
|
+
|
|
25
|
+
type ContextField = {
|
|
26
|
+
type: string;
|
|
27
|
+
column?: string;
|
|
28
|
+
note?: string;
|
|
29
|
+
};
|
|
30
|
+
type ContextSignature = Record<string, ContextField>;
|
|
31
|
+
type MutationEffect = {
|
|
32
|
+
op: Mutation['op'];
|
|
33
|
+
table: string;
|
|
34
|
+
columns: string[];
|
|
35
|
+
};
|
|
36
|
+
declare const collectMutationContext: (def: MutationDefinition, schema?: DatabaseSchema) => ContextSignature;
|
|
37
|
+
declare const collectQueryContext: (dsl: Query, schema?: DatabaseSchema) => ContextSignature;
|
|
38
|
+
declare const mutationEffect: (def: MutationDefinition) => MutationEffect[];
|
|
39
|
+
declare const requiredContextKeys: (m: CoreMutation) => string[];
|
|
40
|
+
declare const lintMutation: (def: MutationDefinition) => string[];
|
|
41
|
+
|
|
42
|
+
type VexHandlerConfig = {
|
|
43
|
+
engine: QueryEngine;
|
|
44
|
+
entities?: string[];
|
|
45
|
+
locked?: boolean;
|
|
46
|
+
scopePolicy?: ScopePolicy;
|
|
47
|
+
policyForReach?: (reach: string) => Promise<ScopePolicy | undefined> | ScopePolicy | undefined;
|
|
48
|
+
mutations?: {
|
|
49
|
+
client: MutationClient;
|
|
50
|
+
policy: ScopePolicy;
|
|
51
|
+
onWrite?: (event: WriteEvent) => void;
|
|
52
|
+
};
|
|
53
|
+
onExecute?: (record: ExecuteRecord) => void;
|
|
54
|
+
};
|
|
55
|
+
type WriteEvent = {
|
|
56
|
+
fingerprint: string;
|
|
57
|
+
writes: WriteResult[];
|
|
58
|
+
scope: ScopeValues;
|
|
59
|
+
};
|
|
60
|
+
type VexLive = {
|
|
61
|
+
signal: AbortSignal;
|
|
62
|
+
onChange: (response: QueryResponse) => void;
|
|
63
|
+
};
|
|
64
|
+
declare const tablesChangedBy: (writes: readonly WriteResult[], schema: DatabaseSchema | undefined) => string[];
|
|
65
|
+
type ExecuteRecord = {
|
|
66
|
+
kind: 'query' | 'mutation';
|
|
67
|
+
status: 'ok' | 'error' | 'refused';
|
|
68
|
+
fingerprint?: string;
|
|
69
|
+
reach?: string;
|
|
70
|
+
cacheHit?: boolean;
|
|
71
|
+
rows?: number;
|
|
72
|
+
startUnixNano: number;
|
|
73
|
+
endUnixNano: number;
|
|
74
|
+
scope: ScopeValues;
|
|
75
|
+
};
|
|
76
|
+
type DiscoveryFingerprint = {
|
|
77
|
+
fingerprint: string;
|
|
78
|
+
kind: 'query' | 'mutation';
|
|
79
|
+
protected: boolean;
|
|
80
|
+
schemaFresh: boolean;
|
|
81
|
+
intent?: string;
|
|
82
|
+
createdAt: number;
|
|
83
|
+
lastUsedAt?: number;
|
|
84
|
+
context?: ContextSignature;
|
|
85
|
+
shape?: unknown;
|
|
86
|
+
effect?: MutationEffect[];
|
|
87
|
+
};
|
|
88
|
+
type DiscoveryResponse = {
|
|
89
|
+
vex: string;
|
|
90
|
+
description: string;
|
|
91
|
+
entities: DiscoveryEntity[];
|
|
92
|
+
protection: 'all' | 'some' | 'none';
|
|
93
|
+
locked: boolean;
|
|
94
|
+
fingerprints: DiscoveryFingerprint[];
|
|
95
|
+
query: {
|
|
96
|
+
method: string;
|
|
97
|
+
accepts: string;
|
|
98
|
+
body: Record<string, DiscoveryField>;
|
|
99
|
+
};
|
|
100
|
+
dsl: object;
|
|
101
|
+
};
|
|
102
|
+
type DiscoveryEntity = {
|
|
103
|
+
name: string;
|
|
104
|
+
fields: Array<{
|
|
105
|
+
name: string;
|
|
106
|
+
type: string;
|
|
107
|
+
nullable: boolean;
|
|
108
|
+
primaryKey: boolean;
|
|
109
|
+
}>;
|
|
110
|
+
relations: Array<{
|
|
111
|
+
entity: string;
|
|
112
|
+
type: string;
|
|
113
|
+
via: string[];
|
|
114
|
+
}>;
|
|
115
|
+
rowCount?: number;
|
|
116
|
+
};
|
|
117
|
+
type DiscoveryField = {
|
|
118
|
+
type: string;
|
|
119
|
+
required: boolean;
|
|
120
|
+
description: string;
|
|
121
|
+
};
|
|
122
|
+
declare const handleDiscovery: (config: VexHandlerConfig) => Promise<DiscoveryResponse>;
|
|
123
|
+
type QueryResult = {
|
|
124
|
+
status: number;
|
|
125
|
+
body: unknown;
|
|
126
|
+
};
|
|
127
|
+
declare const handleQuery: (config: VexHandlerConfig, body: unknown, scope: ScopeValues, live?: VexLive) => Promise<QueryResult>;
|
|
128
|
+
declare const handleFingerprintPatch: (config: VexHandlerConfig, fingerprint: string, patch: {
|
|
129
|
+
protected?: boolean;
|
|
130
|
+
}) => Promise<QueryResult>;
|
|
131
|
+
declare const handleFingerprintDelete: (config: VexHandlerConfig, fingerprint: string) => Promise<QueryResult>;
|
|
132
|
+
|
|
133
|
+
export { type ContextField as C, type DiscoveryFingerprint as D, type ExecuteRecord as E, type MutationClient as M, type QueryResult as Q, type VexHandlerConfig as V, type WriteEvent as W, type ContextSignature as a, type DiscoveryResponse as b, type MutationContext as c, type MutationEffect as d, type MutationTx as e, type VexLive as f, type WriteResult as g, collectMutationContext as h, collectQueryContext as i, executeMutation as j, executeWrites as k, handleDiscovery as l, handleFingerprintDelete as m, handleFingerprintPatch as n, handleQuery as o, lintMutation as p, mutationEffect as q, requiredContextKeys as r, tablesChangedBy as t };
|