@bett3r-dev/pv3-types 1.0.0 → 1.4.0

package/build/aggregateSchema.js

@@ -0,0 +1,287 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateSpecSchema = exports.assertStaticAggregateSpec = exports.assertSafeAggregateIdentifiers = exports.deriveAggregateSchema = exports.AggregateFilterSchema = void 0;
+const jsonschema_definer_1 = __importStar(require("@bett3r-dev/jsonschema-definer"));
+const database_1 = require("./database");
+/**
+ * The filter schema embedded under `aggregate.filter`, carrying its OWN `$id` — see
+ * `collectionFilterSchemaWithId`. Identical rules to `CollectionFilterSchema`, different identity,
+ * because both are materialised in the SAME readmodel query document.
+ */
+exports.AggregateFilterSchema = (0, database_1.collectionFilterSchemaWithId)('AggregateCollectionFilter');
+const errors_1 = require("./errors");
+// `sum`/`avg` are arithmetic: they answer with a total or a mean, which is meaningless over a
+// string or a boolean. `min`/`max`/`count` are NOT arithmetic (they pick an existing value, or
+// tally rows) and stay legal over any type.
+const NUMERIC_TYPES = ['number', 'integer'];
+const isNumericProperty = (property) => {
+    const type = property.type;
+    // `.nullable()` widens `type` to an ARRAY (`['null','number']`), so both shapes must be read.
+    return Array.isArray(type)
+        ? type.some(t => NUMERIC_TYPES.includes(t))
+        : !!type && NUMERIC_TYPES.includes(type);
+};
+/**
+ * A property with NO `type` at all is a real and confusing case: the message used to read
+ * `is of type "undefined"`, which reads like the field is declared as the undefined TYPE rather
+ * than like the declaration is MISSING. The two have different fixes, so they get different words.
+ */
+const describeType = (property) => property?.type === undefined
+    ? 'has no declared type'
+    : `is of type "${property.type}"`;
+const reject = (message) => {
+    // A ValidationError (400), not a bare Error: under Option B the spec crosses HTTP, so the
+    // caller supplying it is a client and a malformed spec is their fault, not a 500.
+    throw new errors_1.ValidationError(`deriveAggregateSchema: ${message}`, 'INVALID_AGGREGATE_SPEC');
+};
+/**
+ * Rejects a spec that cannot produce a trustworthy shape, ALWAYS naming the offending field —
+ * a bare "invalid spec" leaves the author guessing which of several terms is wrong.
+ *
+ * This lives INSIDE the derivation rather than at the HTTP boundary on purpose: the derivation
+ * is the one thing every consumer goes through (`aggregate()`, the endpoint, teselly's
+ * authoring-time validator), so every caller inherits the guarantee. Under Option B that means
+ * a bad rule is rejected when it is SAVED, not at 3am when it runs.
+ */
+const validateSpec = (modelProperties, spec) => {
+    // CHARSET FIRST, membership second: a hostile value is not a property of the model either, so
+    // a membership-first order would report "is not a property of the model" for an injection
+    // attempt and hide what actually happened.
+    (0, exports.assertSafeAggregateIdentifiers)(spec);
+    spec.groupBy.forEach(key => {
+        if (!(key in modelProperties))
+            reject(`groupBy key "${key}" is not a property of the model.`);
+    });
+    const groupKeys = new Set(spec.groupBy);
+    const seenAliases = new Set();
+    spec.aggregates.forEach(term => {
+        // `count` is the only function legal without a field; when one IS given it must still exist.
+        if (term.field !== undefined && !(term.field in modelProperties))
+            reject(`aggregate field "${term.field}" (fn "${term.fn}", as "${term.as}") is not a property of the model.`);
+        if ((term.fn === 'sum' || term.fn === 'avg') && !isNumericProperty(modelProperties[term.field]))
+            reject(`fn "${term.fn}" requires a numeric field, but "${term.field}" ${describeType(modelProperties[term.field])}.`);
+        // THE REGRESSION THIS SLICE CLOSES: the design spike accepted an alias equal to a groupBy
+        // key and SILENTLY CLOBBERED the group key in the derived shape, handing downstream a
+        // number where an account id was declared.
+        if (groupKeys.has(term.as))
+            reject(`alias "${term.as}" collides with a groupBy key of the same name.`);
+        if (seenAliases.has(term.as))
+            reject(`alias "${term.as}" is used by more than one aggregate.`);
+        seenAliases.add(term.as);
+    });
+};
+/**
+ * Derives the RESPONSE SCHEMA of an aggregate row from the model's schema plus the spec.
+ *
+ * This is one of the three co-derivations of a single spec value (the other two being the
+ * `AggregateRow` TS type and the adapter's SQL). It is deliberately a PURE function of
+ * `(modelSchema, spec)` — no ports, no I/O, no dependency on endpoint registration — because
+ * the authoring-time consumer (teselly's rule validator) calls it on a spec pv3 never saw at
+ * build time. Building it as an internal of endpoint registration is the one decision here
+ * that would be expensive to undo.
+ *
+ * The rules:
+ *  - a `groupBy` key copies the model's property schema, facets (enum, format) included, made
+ *    NULLABLE: a row lacking the key groups under SQL NULL, and the adapter projects that group's
+ *    key as JS `null` (invariant I1 — the schema must accept what the SQL can legitimately hand
+ *    back);
+ *  - every OTHER `groupBy` facet survives onto the row rather than being flattened to a loose
+ *    primitive;
+ *  - a `count`/`sum` alias is always `number` — neither can be empty (a group exists because a
+ *    row exists, and the empty sum is COALESCEd to its identity element, 0);
+ *  - an `avg` alias is `number | null`, and a `min`/`max` alias copies the SOURCE field's
+ *    property schema verbatim — facets included (invariant I4) — made NULLABLE. This is the
+ *    half a TS type cannot carry: `AggregateTermType` can say `string`, only the schema can
+ *    say `format: 'date-time'`, and a consumer generating a client from it would otherwise be
+ *    handed a looser contract than the readmodel's own. The nullability mirrors
+ *    `AggregateTermType` exactly: these three functions have no identity element, so a group
+ *    whose every row lacks the field yields null rather than an invented value. `.nullable()`
+ *    is the library's own mechanism and preserves the other facets (it widens `type` and, for
+ *    an enum, appends null to the enum) instead of flattening the schema;
+ *  - every other model property DISAPPEARS — an aggregate row is a new type, not a partial
+ *    model.
+ */
+const deriveAggregateSchema = (modelSchema, spec) => {
+    const modelProperties = modelSchema.plain.properties || {};
+    // Validate BEFORE deriving: a shape derived from a malformed spec is worse than no shape,
+    // because it is permissive (an unknown field used to become `raw( undefined )` — a property
+    // with no constraints at all) and every downstream consumer believes it.
+    validateSpec(modelProperties, spec);
+    const groupProperties = spec.groupBy.reduce((acc, key) => ({
+        ...acc,
+        // A row lacking this key groups under SQL NULL (the adapter projects it as JS `null`), so
+        // the property must be NULLABLE — mirroring the avg/min/max aliases below, `.nullable()` is
+        // used rather than a hand-rolled `anyOf` because it widens `type` and, for an enum, appends
+        // `null` to the enum while leaving every other facet (format, etc.) verbatim.
+        [key]: new jsonschema_definer_1.BaseSchema().raw(modelProperties[key])
+            .nullable()
+    }), {});
+    const aggregateProperties = spec.aggregates.reduce((acc, term) => ({
+        ...acc,
+        [term.as]: term.fn === 'min' || term.fn === 'max' ? new jsonschema_definer_1.BaseSchema().raw(modelProperties[term.field])
+            .nullable()
+            : term.fn === 'avg' ? jsonschema_definer_1.default.number().nullable()
+                : jsonschema_definer_1.default.number()
+    }), {});
+    return jsonschema_definer_1.default.shape({ ...groupProperties, ...aggregateProperties });
+};
+exports.deriveAggregateSchema = deriveAggregateSchema;
+/**
+ * TV1-2342 slice 7 — THE WIRE BOUNDARY.
+ *
+ * Everything below exists because of the resolved fork (Option B): the spec is composed at
+ * AUTHORING time and travels to pv3 IN THE QUERY STRING, so from here on it is untrusted,
+ * attacker-controllable input. In slice 1 the spec was compile-time-bound and none of this was
+ * needed; nothing about `translateAggregate` changed, the THREAT MODEL did.
+ */
+/**
+ * Every identifier in a spec is INTERPOLATED into the statement, never bound:
+ *   - `as`      -> `... AS "${term.as}"`
+ *   - `groupBy` -> `data#>>'{${key}}'` and `(ARRAY_AGG(data#>'{${key}}'))[1]`
+ *   - `field`   -> the same accessors
+ * A parameter placeholder cannot stand in any of those positions, so the ONLY defence is to
+ * refuse anything that is not a plain identifier. This is REJECTION, deliberately, not escaping:
+ * an escaping layer is a thing that can be got subtly wrong once and is then trusted forever,
+ * whereas a charset that admits no quote, no space, no `;` and no `-` cannot express an injection
+ * at all. `maxGroups`/`maxGroupSize` are the other two interpolated values and are guarded by
+ * `Number.isSafeInteger` in the adapter plus the wire schema's `integer` below.
+ *
+ * NOTE ON SCOPE: this admits only TOP-LEVEL identifiers (no dots). That is not a restriction in
+ * practice — `deriveAggregateSchema` already requires every key to be a top-level property of the
+ * model schema — but it is stated so a future reader adding nested-path support knows this guard
+ * is the second place to change.
+ */
+const SAFE_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]{0,62}$/;
+const assertSafeIdentifier = (role, value) => {
+    if (!SAFE_IDENTIFIER.test(value))
+        reject(`${role} "${value}" is not a safe identifier — it must match ${SAFE_IDENTIFIER.source} (it is interpolated into SQL, so it is never escaped or quoted, only rejected).`);
+};
+/**
+ * Charset-checks every value in the spec that reaches SQL by interpolation.
+ *
+ * Called from `validateSpec` (i.e. from INSIDE `deriveAggregateSchema`), so every caller that
+ * DERIVES — the endpoint, teselly's authoring-time validator — inherits it. It is deliberately
+ * NOT only there: `aggregate()` does NOT derive, so the Postgres adapter runs this check itself
+ * (`assertAggregateBoundsAreValid`, postgres.utils.ts) immediately before interpolating. The
+ * derivation is a chokepoint for the HTTP path, not for the port. Exported as well, so the
+ * boundary can run it FIRST and
+ * report "not a safe identifier" instead of the less useful "not a property of the model" that a
+ * membership check would report for the same hostile value.
+ */
+const assertSafeAggregateIdentifiers = (spec) => {
+    spec.groupBy.forEach(key => assertSafeIdentifier('groupBy key', String(key)));
+    spec.aggregates.forEach(term => {
+        if (term.field !== undefined)
+            assertSafeIdentifier('aggregate field', String(term.field));
+        assertSafeIdentifier('alias "as"', String(term.as));
+    });
+};
+exports.assertSafeAggregateIdentifiers = assertSafeAggregateIdentifiers;
+const STATIC_VIOLATION = 'must be a STATIC string literal';
+/**
+ * INVARIANT I5 — the spec must be STATIC.
+ *
+ * This is the condition the whole design rests on, not a hygiene check. `AggregateRow`, the
+ * derived JSON Schema and the SQL are all computed FROM the spec; if a `groupBy` key or an
+ * aggregate `field` can arrive from a runtime value (an upstream edge in a rule graph, a
+ * template placeholder resolved later) then the row shape is not derivable at authoring time and
+ * the entire scheme degrades to `any` — silently, because a spec with a placeholder in it is a
+ * perfectly well-formed object.
+ *
+ * So the two runtime-reference shapes are refused explicitly:
+ *   - a NON-STRING where an identifier belongs (`{ from: 'input.field' }`, the shape a rules-engine
+ *     edge would produce);
+ *   - a string carrying template syntax (`{{...}}`, `${...}`), which would otherwise sail through
+ *     the charset guard's error path with a confusing message.
+ * Run BEFORE the charset guard so the failure names the right problem.
+ */
+const assertStaticAggregateSpec = (spec) => {
+    if (!spec || typeof spec !== 'object' || Array.isArray(spec))
+        reject('the aggregate spec must be an object with a static `groupBy` and `aggregates`.');
+    const candidate = spec;
+    const assertStaticString = (role, value) => {
+        if (typeof value !== 'string')
+            reject(`${role} ${STATIC_VIOLATION}, received ${JSON.stringify(value)} — a runtime-supplied identifier makes the row shape underivable (invariant I5).`);
+        if (/\{\{|\}\}|\$\{/.test(value))
+            reject(`${role} ${STATIC_VIOLATION}, but "${value}" contains template syntax — a runtime-supplied identifier makes the row shape underivable (invariant I5).`);
+    };
+    if (!Array.isArray(candidate.groupBy))
+        reject(`\`groupBy\` must be a STATIC array of literal keys, received ${JSON.stringify(candidate.groupBy)}.`);
+    candidate.groupBy.forEach(key => assertStaticString('groupBy key', key));
+    if (!Array.isArray(candidate.aggregates))
+        reject(`\`aggregates\` must be a STATIC array of literal terms, received ${JSON.stringify(candidate.aggregates)}.`);
+    candidate.aggregates.forEach(term => {
+        if (!term || typeof term !== 'object' || Array.isArray(term))
+            reject(`each aggregate term ${STATIC_VIOLATION.replace('string literal', 'object literal')}, received ${JSON.stringify(term)}.`);
+        const t = term;
+        if (t.field !== undefined)
+            assertStaticString('aggregate field', t.field);
+        assertStaticString('alias "as"', t.as);
+    });
+};
+exports.assertStaticAggregateSpec = assertStaticAggregateSpec;
+/**
+ * The WIRE schema of an aggregate spec — what a caller may put in the query string.
+ *
+ * It validates the spec's SHAPE only (the function vocabulary, the bound types, the filter
+ * clauses). The SEMANTIC rules — field exists on the model, `sum` over a numeric field, alias
+ * collisions — deliberately stay in `deriveAggregateSchema`, which is the single place every
+ * caller passes through. Duplicating them here would create two rule sets that can drift.
+ *
+ * `filter` reuses the same filter DEFINITION (under its own `$id`) so a filter means exactly the same thing on
+ * `aggregate` as it does on `query`.
+ */
+exports.AggregateSpecSchema = jsonschema_definer_1.default.shape({
+    groupBy: jsonschema_definer_1.default.array().items(jsonschema_definer_1.default.string()),
+    aggregates: jsonschema_definer_1.default.array().items(jsonschema_definer_1.default.shape({
+        fn: jsonschema_definer_1.default.string().enum('sum', 'count', 'min', 'max', 'avg'),
+        field: jsonschema_definer_1.default.string().optional(),
+        as: jsonschema_definer_1.default.string()
+    })),
+    // Its OWN `$id`, not `CollectionFilterSchema`'s: `ReadmodelDefaultQuerySchema` embeds a filter at
+    // `filter` AND at `aggregate.filter`, and two identical `$id`s in one document make ajv refuse to
+    // compile the ENTIRE validator. Same rules, same shape, distinct identity.
+    filter: jsonschema_definer_1.default.array().items(exports.AggregateFilterSchema)
+        .optional(),
+    // Interpolated into the statement as a LIMIT, so `integer` here and `Number.isSafeInteger` in
+    // the adapter. Both, deliberately: this one gives the caller a 400 with a useful message, the
+    // adapter's one is what protects a caller that never came through this boundary.
+    maxGroups: jsonschema_definer_1.default.integer().minimum(1)
+        .optional(),
+    maxGroupSize: jsonschema_definer_1.default.integer().minimum(1)
+        .optional()
+});
+//# sourceMappingURL=aggregateSchema.js.map

package/build/aggregateSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregateSchema.js","sourceRoot":"","sources":["../src/aggregateSchema.ts"],"names":[],"mappings":"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"}