@qualifyze/airtable-formulator/lib/schema.js

Airtable Formula Manipulator

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.validate = exports.isOperation = exports.isFunctionCall = exports.createValidator = exports.schema = exports.isOperatorSymbol = exports.isFunctionName = void 0;
const airtable_formula_reference_json_1 = require("./airtable-formula-reference.json");
const ajv_1 = __importDefault(require("ajv"));
const functionNames = new Set(Object.keys(airtable_formula_reference_json_1.functions));
const operatorSymbols = new Set(Object.keys(airtable_formula_reference_json_1.operators));
function isFunctionName(name) {
    // XXX typescript incorrectly enforces the has argument to always be of the type that generic has been cast as.
    return functionNames.has(name);
}
exports.isFunctionName = isFunctionName;
function isOperatorSymbol(symbol) {
    // XXX typescript incorrectly enforces the has argument to always be of the type that generic has been cast as.
    return operatorSymbols.has(symbol);
}
exports.isOperatorSymbol = isOperatorSymbol;
const operatorSymbolSchema = {
    type: "string",
    enum: Array.from(operatorSymbols),
};
const functionNameSchema = {
    type: "string",
    enum: Array.from(functionNames),
};
const operationName = "operation";
const functionCallName = "functionCall";
function ref(name) {
    return {
        $ref: `#/definitions/${name}`,
    };
}
const literalSchema = {
    anyOf: [
        {
            type: "string",
        },
        {
            type: "number",
        },
        {
            type: "boolean",
        },
    ],
};
const fieldReferenceSchema = {
    type: "object",
    properties: {
        field: {
            type: "string",
        },
    },
    maxProperties: 1,
    additionalProperties: false,
    required: ["field"],
};
const argSchemaList = [
    literalSchema,
    ref(operationName),
    ref(functionCallName),
    fieldReferenceSchema,
];
const functionCallSchema = {
    type: "array",
    items: [functionNameSchema],
    additionalItems: {
        anyOf: argSchemaList,
    },
    minItems: 1,
    maxItems: 1024,
};
const operationSchema = {
    type: "array",
    items: [operatorSymbolSchema],
    additionalItems: {
        anyOf: argSchemaList,
    },
    minItems: 1,
    maxItems: 1024,
};
exports.schema = {
    definitions: {
        [functionCallName]: functionCallSchema,
        [operationName]: operationSchema,
    },
    anyOf: [
        literalSchema,
        operationSchema,
        functionCallSchema,
        fieldReferenceSchema,
    ],
};
function createValidator(ajv = new ajv_1.default({ strict: false })) {
    return ajv.compile(exports.schema);
}
exports.createValidator = createValidator;
function isFunctionCall(formula) {
    return Array.isArray(formula) && isFunctionName(formula[0]);
}
exports.isFunctionCall = isFunctionCall;
function isOperation(formula) {
    return Array.isArray(formula) && isOperatorSymbol(formula[0]);
}
exports.isOperation = isOperation;
const _validate = createValidator();
function validate(data) {
    return _validate(data) ? [] : _validate.errors || [];
}
exports.validate = validate;
//# sourceMappingURL=schema.js.map