@niscorp/vex 0.2.2 → 0.2.3
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/CHANGELOG.md +121 -0
- package/DESIGN.md +66 -3
- package/DOCS.md +156 -12
- package/dist/adapters/express/index.cjs +102 -17
- package/dist/adapters/express/index.cjs.map +1 -1
- package/dist/adapters/express/index.d.cts +2 -2
- package/dist/adapters/express/index.d.ts +2 -2
- package/dist/adapters/express/index.js +2 -2
- package/dist/adapters/hono/index.cjs +121 -22
- package/dist/adapters/hono/index.cjs.map +1 -1
- package/dist/adapters/hono/index.d.cts +2 -2
- package/dist/adapters/hono/index.d.ts +2 -2
- package/dist/adapters/hono/index.js +21 -7
- package/dist/adapters/hono/index.js.map +1 -1
- package/dist/agent/index.cjs +2 -0
- package/dist/agent/index.cjs.map +1 -1
- package/dist/agent/index.d.cts +1 -1
- package/dist/agent/index.d.ts +1 -1
- package/dist/agent/index.js +1 -1
- package/dist/{chunk-HF25Q53I.js → chunk-H4BHW76Q.js} +6 -3
- package/dist/chunk-H4BHW76Q.js.map +1 -0
- package/dist/{chunk-HCEH55PP.js → chunk-IQM4SQE2.js} +123 -21
- package/dist/chunk-IQM4SQE2.js.map +1 -0
- package/dist/{handler-Cql8SJ3F.d.cts → handler-BGCL6_Si.d.ts} +3 -2
- package/dist/{handler-mICf9ins.d.ts → handler-CMrjTXNx.d.cts} +3 -2
- package/dist/index.cjs +163 -35
- package/dist/index.cjs.map +1 -1
- package/dist/index.d.cts +3 -3
- package/dist/index.d.ts +3 -3
- package/dist/index.js +44 -22
- package/dist/index.js.map +1 -1
- package/dist/{types-BRvMB6IM.d.cts → types-Bi-Lg86b.d.cts} +48 -2
- package/dist/{types-BRvMB6IM.d.ts → types-Bi-Lg86b.d.ts} +48 -2
- package/package.json +5 -5
- package/dist/chunk-HCEH55PP.js.map +0 -1
- package/dist/chunk-HF25Q53I.js.map +0 -1
|
@@ -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-H4BHW76Q.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\n// ONE CLASS, SEVERAL COPIES. The CommonJS build gives each entry point\n// (`@niscorp/vex`, `/hono`, `/express`, `/agent`) its own copy of this class,\n// and an app can load the ESM and CommonJS builds side by side — so an error\n// thrown by an engine from one entry is not an `instanceof` the VexError\n// another entry holds. Every copy puts the same mark on its prototype, under a\n// key the whole process shares, and `isVexError` reads the mark. Wherever vex\n// itself asks \"is this one of ours\", it asks that, never `instanceof`.\nconst VEX_ERROR = Symbol.for('@niscorp/vex:VexError');\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\n// On the prototype, not the instance: a subclass inherits it, and nothing an\n// app prints, serializes or enumerates on an error changes.\nObject.defineProperty(VexError.prototype, VEX_ERROR, { value: true });\n\nexport const isVexError = (err: unknown): err is VexError =>\n err instanceof VexError || (err instanceof Error && Reflect.get(err, VEX_ERROR) === true);\n"]}
|
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
import { FilterSchema, VexError, QuerySchema, isFieldPathShape } from './chunk-
|
|
1
|
+
import { FilterSchema, FieldPathSchema, VexError, QuerySchema, isVexError, isFieldPathShape } from './chunk-H4BHW76Q.js';
|
|
2
2
|
import { z } from 'zod';
|
|
3
3
|
import { exceedsDepth, depthRefusal } from '@niscorp/strata';
|
|
4
4
|
|
|
@@ -806,13 +806,21 @@ var LookupSchema = z.object({
|
|
|
806
806
|
where: FilterSchema.describe("Bounds the lookup \u2014 should match at most one row")
|
|
807
807
|
}).strict()
|
|
808
808
|
}).strict().describe("Scalar subquery: reads one value from another table at write time; read scope rules apply");
|
|
809
|
+
var ReturnedSchema = z.object({
|
|
810
|
+
$returned: FieldPathSchema.describe(
|
|
811
|
+
"`table.column`: `table` is written by exactly one earlier statement of this batch; `column` is a column of that table, including one the database generated."
|
|
812
|
+
)
|
|
813
|
+
}).strict().describe(
|
|
814
|
+
"A column of the one row an earlier statement of this batch (an insert, update, upsert or delete) returned \u2014 how a later row gets an id the database generated. That statement must return exactly one row; none (its `where` matched no row, or scope kept the row back) or several fails the whole batch and nothing is written. Allowed only as the value of a column a statement sets; never inside a `where`, a `$lookup` or `items`, and never naming an `insertEach` or an `insert` whose `onConflict` has no `set`."
|
|
815
|
+
);
|
|
809
816
|
var ValueSchema = z.union([
|
|
810
817
|
z.string(),
|
|
811
818
|
z.number(),
|
|
812
819
|
z.boolean(),
|
|
813
820
|
z.null(),
|
|
814
821
|
z.object({ $context: z.string() }).strict(),
|
|
815
|
-
LookupSchema
|
|
822
|
+
LookupSchema,
|
|
823
|
+
ReturnedSchema
|
|
816
824
|
]);
|
|
817
825
|
var Columns = z.record(z.string(), ValueSchema).refine((r) => Object.keys(r).length > 0, { message: "a write must set at least one column" });
|
|
818
826
|
var OnConflictSchema = z.object({
|
|
@@ -910,17 +918,23 @@ var walkFilter = (filter, schema, sig) => {
|
|
|
910
918
|
};
|
|
911
919
|
var isLookupRef = (v) => v !== null && typeof v === "object" && !Array.isArray(v) && "$lookup" in v;
|
|
912
920
|
var columnsOf = (m) => m.op === "insert" || m.op === "insertEach" ? { ...m.values, ...m.onConflict?.set ?? {} } : m.op === "update" ? m.set : m.op === "upsert" ? { ...m.columns, ...m.insert ?? {} } : {};
|
|
921
|
+
var positionsSetBy = (m) => {
|
|
922
|
+
const positions = (cols, insertOnly = false) => Object.entries(cols ?? {}).map(([column, value]) => ({ column, value, insertOnly }));
|
|
923
|
+
if (m.op === "insert" || m.op === "insertEach") return [...positions(m.values), ...positions(m.onConflict?.set)];
|
|
924
|
+
if (m.op === "update") return positions(m.set);
|
|
925
|
+
if (m.op === "upsert") return [...positions(m.columns), ...positions(m.insert, true)];
|
|
926
|
+
return [];
|
|
927
|
+
};
|
|
913
928
|
var collectMutationContext = (def, schema) => {
|
|
914
929
|
const sig = {};
|
|
915
930
|
const list = Array.isArray(def) ? def : [def];
|
|
916
931
|
for (const m of list) {
|
|
917
|
-
for (const
|
|
932
|
+
for (const { column: col, value: v, insertOnly } of positionsSetBy(m)) {
|
|
918
933
|
if (isLookupRef(v)) {
|
|
919
934
|
walkFilter(v.$lookup.where, schema, sig);
|
|
920
935
|
continue;
|
|
921
936
|
}
|
|
922
937
|
if (!isContextRef(v)) continue;
|
|
923
|
-
const insertOnly = m.op === "upsert" && m.insert !== void 0 && col in m.insert;
|
|
924
938
|
addField(sig, v.$context, { ...columnInfo(`${m.table}.${col}`, schema), ...insertOnly ? { note: "insert only" } : {} });
|
|
925
939
|
}
|
|
926
940
|
if (m.op === "update" || m.op === "delete") walkFilter(m.where, schema, sig);
|
|
@@ -958,8 +972,7 @@ var mutationEffect = (def) => {
|
|
|
958
972
|
};
|
|
959
973
|
var requiredContextKeys = (m) => {
|
|
960
974
|
const keys = /* @__PURE__ */ new Set();
|
|
961
|
-
const
|
|
962
|
-
for (const v of Object.values(cols)) {
|
|
975
|
+
for (const { value: v } of positionsSetBy(m)) {
|
|
963
976
|
if (isContextRef(v)) keys.add(v.$context);
|
|
964
977
|
else if (isLookupRef(v)) {
|
|
965
978
|
const sub = {};
|
|
@@ -981,9 +994,40 @@ var findOptional = (value) => {
|
|
|
981
994
|
if ("optional" in value) return true;
|
|
982
995
|
return Object.values(value).some(findOptional);
|
|
983
996
|
};
|
|
997
|
+
var isReturnedRef = (v) => v !== null && typeof v === "object" && !Array.isArray(v) && "$returned" in v && typeof v.$returned === "string";
|
|
998
|
+
var returnedIn = (list, at) => {
|
|
999
|
+
const refs = /* @__PURE__ */ new Map();
|
|
1000
|
+
const issues = [];
|
|
1001
|
+
const m = list[at];
|
|
1002
|
+
if (m === void 0) return { refs, issues };
|
|
1003
|
+
const judged = /* @__PURE__ */ new Set();
|
|
1004
|
+
for (const { value: v } of positionsSetBy(m)) {
|
|
1005
|
+
if (!isReturnedRef(v) || judged.has(v.$returned)) continue;
|
|
1006
|
+
judged.add(v.$returned);
|
|
1007
|
+
const dot = v.$returned.indexOf(".");
|
|
1008
|
+
const table = v.$returned.slice(0, dot);
|
|
1009
|
+
const column = v.$returned.slice(dot + 1);
|
|
1010
|
+
const reads = `${m.op} on "${m.table}" reads "${v.$returned}"`;
|
|
1011
|
+
const earlier = list.flatMap((s, i) => i < at && s.table === table ? [{ s, i }] : []);
|
|
1012
|
+
const source = earlier[0];
|
|
1013
|
+
if (source === void 0) {
|
|
1014
|
+
issues.push(`${reads}, and no earlier statement writes "${table}" \u2014 put the statement that writes it before this one, in the same batch`);
|
|
1015
|
+
} else if (earlier.length > 1) {
|
|
1016
|
+
issues.push(`${reads}, and ${earlier.length} earlier statements write "${table}" \u2014 a reference cannot tell them apart`);
|
|
1017
|
+
} else if (source.s.op === "insertEach") {
|
|
1018
|
+
issues.push(`${reads} from an insertEach, which writes a row per element \u2014 there is no one row to read`);
|
|
1019
|
+
} else if (source.s.op === "insert" && source.s.onConflict !== void 0 && source.s.onConflict.set === void 0) {
|
|
1020
|
+
issues.push(`${reads} from an insert that does nothing on conflict, which then returns no row \u2014 give its onConflict a \`set\``);
|
|
1021
|
+
} else {
|
|
1022
|
+
refs.set(v.$returned, { statement: source.i, table, column });
|
|
1023
|
+
}
|
|
1024
|
+
}
|
|
1025
|
+
return { refs, issues };
|
|
1026
|
+
};
|
|
984
1027
|
var lintMutation = (def) => {
|
|
985
1028
|
const issues = [];
|
|
986
1029
|
const list = Array.isArray(def) ? def : [def];
|
|
1030
|
+
list.forEach((_m, at) => issues.push(...returnedIn(list, at).issues));
|
|
987
1031
|
for (const m of list) {
|
|
988
1032
|
if (findOptional(m)) {
|
|
989
1033
|
issues.push(`${m.op} on "${m.table}" contains an optional condition \u2014 a write's bounds cannot depend on what the caller chose to send`);
|
|
@@ -1001,6 +1045,7 @@ var lintMutation = (def) => {
|
|
|
1001
1045
|
// src/mutations/engine.ts
|
|
1002
1046
|
var isLookup = (v) => v !== null && typeof v === "object" && !Array.isArray(v) && "$lookup" in v;
|
|
1003
1047
|
var isItemRef = (v) => v !== null && typeof v === "object" && !Array.isArray(v) && "$item" in v;
|
|
1048
|
+
var isReturned = (v) => v !== null && typeof v === "object" && !Array.isArray(v) && "$returned" in v;
|
|
1004
1049
|
var collectLookups = (m) => {
|
|
1005
1050
|
const out = [];
|
|
1006
1051
|
const scan = (cols) => {
|
|
@@ -1098,6 +1143,13 @@ var assertWritableColumns = (m, schema) => {
|
|
|
1098
1143
|
if (m.onConflict.where !== void 0) assertFilterColumns(m.onConflict.where, m.table, schema, "onConflict");
|
|
1099
1144
|
}
|
|
1100
1145
|
};
|
|
1146
|
+
var assertReturnedColumns = (refs, schema) => {
|
|
1147
|
+
for (const [ref, source] of refs) {
|
|
1148
|
+
if (findEntity(source.table, schema)?.fields.some((f) => f.name === source.column) !== true) {
|
|
1149
|
+
throw new VexError("invalid_dsl", `Unknown column "${ref}" in $returned.`);
|
|
1150
|
+
}
|
|
1151
|
+
}
|
|
1152
|
+
};
|
|
1101
1153
|
var readMatchesFor = (table, policy) => {
|
|
1102
1154
|
const rule = policy.entities[table];
|
|
1103
1155
|
if (rule === void 0) {
|
|
@@ -1206,7 +1258,8 @@ var newCtx = () => ({
|
|
|
1206
1258
|
resolvedPaths: /* @__PURE__ */ new Map(),
|
|
1207
1259
|
aliasMap: /* @__PURE__ */ new Map(),
|
|
1208
1260
|
paramSlots: [],
|
|
1209
|
-
paramCounter: { value: 0 }
|
|
1261
|
+
paramCounter: { value: 0 },
|
|
1262
|
+
returned: /* @__PURE__ */ new Map()
|
|
1210
1263
|
});
|
|
1211
1264
|
var indexFilterFields = (filter, aliasMap) => {
|
|
1212
1265
|
for (const path of filterColumns(filter)) aliasMap.set(path, path);
|
|
@@ -1217,13 +1270,19 @@ var compileValue = (v, ctx) => {
|
|
|
1217
1270
|
const where = compileFilter(v.$lookup.where, ctx);
|
|
1218
1271
|
return `(SELECT ${v.$lookup.field} FROM ${v.$lookup.from} WHERE ${where})`;
|
|
1219
1272
|
}
|
|
1273
|
+
if (isReturned(v)) {
|
|
1274
|
+
ctx.paramCounter.value += 1;
|
|
1275
|
+
ctx.returned.set(ctx.paramSlots.length, v.$returned);
|
|
1276
|
+
ctx.paramSlots.push({ key: v.$returned, kind: "context", type: "string" });
|
|
1277
|
+
return `$${ctx.paramCounter.value}`;
|
|
1278
|
+
}
|
|
1220
1279
|
return compileFieldOrValue(v, ctx);
|
|
1221
1280
|
};
|
|
1222
1281
|
var compileColumnValue = (table, column, v, ctx, schema) => {
|
|
1223
1282
|
const before = ctx.paramSlots.length;
|
|
1224
1283
|
const sql = compileValue(v, ctx);
|
|
1225
1284
|
const json = findEntity(table, schema)?.fields.find((f) => f.name === column)?.normalizedType === "json";
|
|
1226
|
-
if (json && typeof v === "object" && v !== null && "$context" in v) {
|
|
1285
|
+
if (json && typeof v === "object" && v !== null && ("$context" in v || "$returned" in v)) {
|
|
1227
1286
|
const slot = ctx.paramSlots[before];
|
|
1228
1287
|
if (slot !== void 0) ctx.paramSlots[before] = { ...slot, encode: "json" };
|
|
1229
1288
|
}
|
|
@@ -1254,7 +1313,7 @@ var compileMutation = (m, schema) => {
|
|
|
1254
1313
|
const entries = Object.entries(m.values);
|
|
1255
1314
|
const cols = entries.map(([c]) => c);
|
|
1256
1315
|
const vals = entries.map(([c, v]) => compileColumnValue(m.table, c, v, ctx, schema));
|
|
1257
|
-
return { sql: `INSERT INTO ${m.table} (${cols.join(", ")}) VALUES (${vals.join(", ")})${compileConflict(m, ctx, schema)} RETURNING *`, slots: ctx.paramSlots };
|
|
1316
|
+
return { sql: `INSERT INTO ${m.table} (${cols.join(", ")}) VALUES (${vals.join(", ")})${compileConflict(m, ctx, schema)} RETURNING *`, slots: ctx.paramSlots, returned: ctx.returned };
|
|
1258
1317
|
}
|
|
1259
1318
|
if (m.op === "insertEach") {
|
|
1260
1319
|
const entity = findEntity(m.table, schema);
|
|
@@ -1268,25 +1327,26 @@ var compileMutation = (m, schema) => {
|
|
|
1268
1327
|
const raw = `(item.value->>${quoteLiteral(v.$item)})`;
|
|
1269
1328
|
return cast === void 0 ? raw : `${raw}::${cast}`;
|
|
1270
1329
|
}
|
|
1271
|
-
return compileValue(v, ctx);
|
|
1330
|
+
return isReturned(v) ? compileColumnValue(m.table, col, v, ctx, schema) : compileValue(v, ctx);
|
|
1272
1331
|
});
|
|
1273
1332
|
ctx.paramCounter.value += 1;
|
|
1274
1333
|
ctx.paramSlots.push({ key: m.items.$context, kind: "context", type: "json" });
|
|
1275
1334
|
const source = `jsonb_array_elements($${ctx.paramCounter.value}::jsonb) AS item`;
|
|
1276
1335
|
return {
|
|
1277
1336
|
sql: `INSERT INTO ${m.table} (${cols.join(", ")}) SELECT ${exprs.join(", ")} FROM ${source}${compileConflict(m, ctx, schema)} RETURNING *`,
|
|
1278
|
-
slots: ctx.paramSlots
|
|
1337
|
+
slots: ctx.paramSlots,
|
|
1338
|
+
returned: ctx.returned
|
|
1279
1339
|
};
|
|
1280
1340
|
}
|
|
1281
1341
|
if (m.op === "update") {
|
|
1282
1342
|
const sets = Object.entries(m.set).map(([c, v]) => `${c} = ${compileColumnValue(m.table, c, v, ctx, schema)}`);
|
|
1283
1343
|
indexFilterFields(m.where, ctx.aliasMap);
|
|
1284
1344
|
const where2 = compileFilter(m.where, ctx);
|
|
1285
|
-
return { sql: `UPDATE ${m.table} SET ${sets.join(", ")} WHERE ${where2} RETURNING *`, slots: ctx.paramSlots };
|
|
1345
|
+
return { sql: `UPDATE ${m.table} SET ${sets.join(", ")} WHERE ${where2} RETURNING *`, slots: ctx.paramSlots, returned: ctx.returned };
|
|
1286
1346
|
}
|
|
1287
1347
|
indexFilterFields(m.where, ctx.aliasMap);
|
|
1288
1348
|
const where = compileFilter(m.where, ctx);
|
|
1289
|
-
return { sql: `DELETE FROM ${m.table} WHERE ${where} RETURNING *`, slots: ctx.paramSlots };
|
|
1349
|
+
return { sql: `DELETE FROM ${m.table} WHERE ${where} RETURNING *`, slots: ctx.paramSlots, returned: ctx.returned };
|
|
1290
1350
|
};
|
|
1291
1351
|
var SUGAR = {
|
|
1292
1352
|
upsert: (m, context) => {
|
|
@@ -1298,27 +1358,69 @@ var desugarMutation = (m, context) => {
|
|
|
1298
1358
|
const rewrite = SUGAR[m.op];
|
|
1299
1359
|
return rewrite === void 0 ? m : rewrite(m, context);
|
|
1300
1360
|
};
|
|
1361
|
+
var mutationMisfits = (def, schema) => {
|
|
1362
|
+
const reasons = [];
|
|
1363
|
+
const list = Array.isArray(def) ? def : [def];
|
|
1364
|
+
for (const [at, entry] of list.entries()) {
|
|
1365
|
+
const asked = [
|
|
1366
|
+
// keyed, an upsert is an update; unkeyed, an insert
|
|
1367
|
+
...(entry.op === "upsert" ? [{ [entry.key]: 0 }, {}] : [{}]).map((context) => () => assertWritableColumns(desugarMutation(entry, context), schema)),
|
|
1368
|
+
() => assertReturnedColumns(returnedIn(list, at).refs, schema)
|
|
1369
|
+
];
|
|
1370
|
+
for (const ask of asked) {
|
|
1371
|
+
try {
|
|
1372
|
+
ask();
|
|
1373
|
+
} catch (error) {
|
|
1374
|
+
reasons.push(error instanceof Error ? error.message : String(error));
|
|
1375
|
+
}
|
|
1376
|
+
}
|
|
1377
|
+
}
|
|
1378
|
+
return reasons;
|
|
1379
|
+
};
|
|
1301
1380
|
var executeWrites = async (client, def, mctx) => {
|
|
1302
1381
|
const parsed = MutationDefinitionSchema.parse(def);
|
|
1303
1382
|
const entries = Array.isArray(parsed) ? parsed : [parsed];
|
|
1304
|
-
const
|
|
1305
|
-
|
|
1383
|
+
const cores = entries.map((entry) => desugarMutation(entry, mctx.context));
|
|
1384
|
+
const compiled = cores.map((core, at) => {
|
|
1306
1385
|
const missing = requiredContextKeys(core).filter((k) => mctx.context[k] === void 0);
|
|
1307
1386
|
if (missing.length > 0) {
|
|
1308
1387
|
throw new VexError("missing_context", `Mutation is missing context: ${missing.join(", ")}.`, {
|
|
1309
1388
|
expected: collectMutationContext(parsed, mctx.schema)
|
|
1310
1389
|
});
|
|
1311
1390
|
}
|
|
1391
|
+
const returned = returnedIn(cores, at);
|
|
1392
|
+
if (returned.issues.length > 0) throw new VexError("invalid_dsl", `${returned.issues.join("; ")}.`);
|
|
1312
1393
|
const m = scopeMutation(core, mctx.policy);
|
|
1313
1394
|
assertWritableColumns(m, mctx.schema);
|
|
1395
|
+
assertReturnedColumns(returned.refs, mctx.schema);
|
|
1314
1396
|
const statement = compileMutation(m, mctx.schema);
|
|
1315
1397
|
requireScope({ paramSlots: statement.slots }, mctx.scope);
|
|
1316
|
-
|
|
1398
|
+
const reads = [...statement.returned].map(([slot, ref]) => {
|
|
1399
|
+
const source = returned.refs.get(ref);
|
|
1400
|
+
if (source === void 0) throw new VexError("invalid_dsl", `"${ref}" names no earlier statement of the batch.`);
|
|
1401
|
+
return { slot, ref, source };
|
|
1402
|
+
});
|
|
1403
|
+
return { ...statement, reads, table: m.table, op: m.op === "insertEach" ? "insert" : m.op };
|
|
1317
1404
|
});
|
|
1318
1405
|
const runAll = async (q) => {
|
|
1319
1406
|
const results = [];
|
|
1320
1407
|
for (const c of compiled) {
|
|
1321
1408
|
const params = await resolveParams(c.slots, mctx.context, mctx.scope);
|
|
1409
|
+
for (const read of c.reads) {
|
|
1410
|
+
const rows = results[read.source.statement]?.rows ?? [];
|
|
1411
|
+
const row = rows[0];
|
|
1412
|
+
if (rows.length !== 1 || row === void 0) {
|
|
1413
|
+
throw new VexError(
|
|
1414
|
+
"execution_error",
|
|
1415
|
+
`"${read.ref}" needs exactly one row from statement ${read.source.statement + 1} of the batch, which wrote ${rows.length}. Nothing was written.`,
|
|
1416
|
+
{ returned: read.ref, rows: rows.length }
|
|
1417
|
+
);
|
|
1418
|
+
}
|
|
1419
|
+
if (!(read.source.column in row)) {
|
|
1420
|
+
throw new VexError("execution_error", `"${read.ref}": the row statement ${read.source.statement + 1} returned has no "${read.source.column}" key. Nothing was written.`, { returned: read.ref });
|
|
1421
|
+
}
|
|
1422
|
+
params[read.slot] = row[read.source.column];
|
|
1423
|
+
}
|
|
1322
1424
|
const bound = params.map((value, i) => {
|
|
1323
1425
|
if (c.slots[i]?.encode === "json") return value !== null && typeof value === "object" ? JSON.stringify(value) : value;
|
|
1324
1426
|
if (c.slots[i]?.type !== "json") return value;
|
|
@@ -1617,11 +1719,11 @@ var runQuery = async (config, body, scope, probe, live) => {
|
|
|
1617
1719
|
}
|
|
1618
1720
|
return { status: 200, body: response };
|
|
1619
1721
|
} catch (err) {
|
|
1620
|
-
if (err
|
|
1722
|
+
if (isVexError(err) && err.code === "missing_scope") {
|
|
1621
1723
|
console.error("[vex] refused a statement the host did not scope:", err.message);
|
|
1622
1724
|
return { status: 500, body: { error: "missing_scope", message: "The server did not supply the scope this request needs." } };
|
|
1623
1725
|
}
|
|
1624
|
-
if (err
|
|
1726
|
+
if (isVexError(err)) {
|
|
1625
1727
|
const status = err.code === "fingerprint_protected" ? 409 : err.code === "cache_miss" ? 404 : 400;
|
|
1626
1728
|
return {
|
|
1627
1729
|
status,
|
|
@@ -1671,6 +1773,6 @@ var handleFingerprintDelete = async (config, fingerprint) => {
|
|
|
1671
1773
|
return { status: 200, body: { fingerprint, deleted: true } };
|
|
1672
1774
|
};
|
|
1673
1775
|
|
|
1674
|
-
export { MutationDefinitionSchema, MutationSchema, QueryRequestSchema, VexScopeError, applyScope, buildContextContract, buildValidationContext, canReadTable, canonicalHash, canonicalText, checkScope, collectMutationContext, collectQueryContext, compileAggregate, compileCompute, compileFieldOrValue, compileFilter, compileJoinPairs, computePolicyKey, computeRequestHash, computeSchemaFingerprint, executeMutation, executeQuery, executeWrites, findMissingContext, fireAndForget, handleDiscovery, handleFingerprintDelete, handleFingerprintPatch, handleQuery, hashText, isEntryFresh, isSetMatch, isTouchDue, lintMutation, mintFingerprint, mutationEffect, normalizeShape, optionalKeysOf, presenceOf, presenceSignature, pruneOptional, quoteIdent, refuseOptional, requireScope, requiredContextKeys, resolveParams, scopeResolved, sweepCache, tablesChangedBy };
|
|
1675
|
-
//# sourceMappingURL=chunk-
|
|
1676
|
-
//# sourceMappingURL=chunk-
|
|
1776
|
+
export { MutationDefinitionSchema, MutationSchema, QueryRequestSchema, VexScopeError, applyScope, buildContextContract, buildValidationContext, canReadTable, canonicalHash, canonicalText, checkScope, collectMutationContext, collectQueryContext, compileAggregate, compileCompute, compileFieldOrValue, compileFilter, compileJoinPairs, computePolicyKey, computeRequestHash, computeSchemaFingerprint, executeMutation, executeQuery, executeWrites, findMissingContext, fireAndForget, handleDiscovery, handleFingerprintDelete, handleFingerprintPatch, handleQuery, hashText, isEntryFresh, isSetMatch, isTouchDue, lintMutation, mintFingerprint, mutationEffect, mutationMisfits, normalizeShape, optionalKeysOf, presenceOf, presenceSignature, pruneOptional, quoteIdent, refuseOptional, requireScope, requiredContextKeys, resolveParams, scopeResolved, sweepCache, tablesChangedBy };
|
|
1777
|
+
//# sourceMappingURL=chunk-IQM4SQE2.js.map
|
|
1778
|
+
//# sourceMappingURL=chunk-IQM4SQE2.js.map
|