@getanthill/datastore
Version:
Event-Sourced Datastore
127 lines • 4.56 kB
JavaScript
;
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;
};
})();
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.getEventTypes = getEventTypes;
exports.getEventTypeVersions = getEventTypeVersions;
exports.validate = validate;
const util_1 = __importDefault(require("util"));
const node_assert_1 = __importDefault(require("node:assert"));
const telemetry = __importStar(require("@getanthill/telemetry"));
/**
* Returns available event types
* @param {object} schema Event schemas
* @returns {string[]} Event type available versions
*/
function getEventTypes(events) {
return Object.keys(events);
}
/**
* Returns available versions for an event type
* @param {object} schema Event schemas
* @param {object} event Object for which the type versions must be returned
* @returns {integer[]} Event type available versions
*/
function getEventTypeVersions(schema, event) {
const versions = Object.keys(schema.schema.events[event.type]).sort();
return {
v: event.v,
all: versions,
};
}
/**
* Validate an event against a JSON Schema contract
* @param {object} event The object to validate
* @param {object} schema The event schema
* @param {object} validator The JSON Schema validator
* @throws AssertionError if invalid
* @returns {void} -
*/
function validate(event, schema, validator, throwOnInvalidEvent = true) {
if (!schema.schema.events[event.type]) {
const err = new node_assert_1.default.AssertionError({
message: 'Invalid event type',
});
// @ts-ignore
err.details = getEventTypes(schema.schema.events);
throw err;
}
const eventSchema = event.v
? schema.schema.events[event.type][event.v]
: undefined;
if (!eventSchema) {
const err = new node_assert_1.default.AssertionError({
message: 'Invalid event type version',
});
// @ts-ignore
err.details = getEventTypeVersions(schema, event);
throw err;
}
const schemaId = `${event.type}.${event.v}`;
let validate = validator.getSchema(schemaId);
if (!validate) {
validator.addSchema(eventSchema, schemaId);
validate = validator.getSchema(schemaId);
}
const isValid = validate(event);
if (!isValid && throwOnInvalidEvent === true) {
telemetry.logger.error('[Events] Validation error', {
errors: validate.errors,
});
const assertionErrorPayload = {
message: 'Event schema validation error',
expected: null,
actual: util_1.default.inspect({
schema: eventSchema,
event,
errors: validate.errors,
}, false, null, false),
};
const err = new node_assert_1.default.AssertionError(assertionErrorPayload);
// @ts-ignore
err.details = validate.errors;
// @ts-ignore
err.details.push({
event,
});
// @ts-ignore
err.event = event;
throw err;
}
return eventSchema;
}
//# sourceMappingURL=events.js.map