@based/schema 2.7.1 → 3.0.1

package/dist/types.d.ts

@@ -0,0 +1,205 @@
+import type { Language } from './languages';
+import type { PartialDeep } from 'type-fest';
+import { ParseError } from './error';
+import { ArgsClass, Path } from './walker';
+import { StringFormat } from './display/string';
+import { NumberFormat } from './display/number';
+import { DateFormat } from './display/timestamp';
+export type AllowedTypes = (string | {
+    type?: string;
+    $filter: any | any[];
+})[];
+export declare const basedSchemaFieldTypes: readonly ["array", "object", "record", "set", "string", "boolean", "number", "json", "integer", "timestamp", "reference", "references", "text", "enum", "cardinality"];
+export type BasedSchemaFieldType = (typeof basedSchemaFieldTypes)[number];
+export declare const isCollection: (type: string) => boolean;
+export type BasedSchemaPattern = string;
+export type BasedSchemaLanguage = Language;
+export declare const languages: string[];
+export type BasedSchemaTypePrefix = string;
+export type BasedSchemaContentMediaType = 'text/html' | 'text/plain' | 'text/markdown' | 'image/png' | 'image/jpeg' | 'video/mp4' | 'image/*' | 'video/*' | 'audio/*' | '*/*' | `${string}/${string}`;
+export type BasedSchemaFieldShared = {
+    hooks?: {
+        interval?: number;
+        hook: string;
+    } | {
+        interval?: number;
+        hook: string;
+    }[];
+    type?: BasedSchemaFieldType;
+    $id?: string;
+    $schema?: string;
+    isRequired?: boolean;
+    title?: string;
+    description?: string;
+    index?: number;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    $comment?: string;
+    examples?: any[];
+    default?: any;
+    customValidator?: (value: any, path: (number | string)[], target: BasedSetTarget) => Promise<boolean>;
+    $defs?: {
+        [key: string]: BasedSchemaField;
+    };
+    $delete?: boolean;
+};
+export type BasedSchemaStringShared = {
+    minLength?: number;
+    maxLength?: number;
+    contentMediaEncoding?: string;
+    contentMediaType?: BasedSchemaContentMediaType;
+    pattern?: BasedSchemaPattern;
+    format?: 'email' | 'URL' | 'MACAddress' | 'IP' | 'IPRange' | 'FQDN' | 'IBAN' | 'BIC' | 'alpha' | 'alphaLocales' | 'alphanumeric' | 'alphanumericLocales' | 'passportNumber' | 'port' | 'lowercase' | 'uppercase' | 'ascii' | 'semVer' | 'surrogatePair' | 'IMEI' | 'hexadecimal' | 'octal' | 'hexColor' | 'rgbColor' | 'HSL' | 'ISRC' | 'MD5' | 'JWT' | 'UUID' | 'luhnNumber' | 'creditCard' | 'identityCard' | 'EAN' | 'ISIN' | 'ISBN' | 'ISSN' | 'mobilePhone' | 'mobilePhoneLocales' | 'postalCode' | 'postalCodeLocales' | 'ethereumAddress' | 'currency' | 'btcAddress' | 'ISO6391' | 'ISO8601' | 'RFC3339' | 'ISO31661Alpha2' | 'ISO31661Alpha3' | 'ISO4217' | 'base32' | 'base58' | 'base64' | 'dataURI' | 'magnetURI' | 'mimeType' | 'latLong' | 'slug' | 'strongPassword' | 'taxID' | 'licensePlate' | 'VAT';
+    display?: StringFormat;
+    multiline?: boolean;
+};
+type NumberDefaults = {
+    multipleOf?: number;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMaximum?: boolean;
+    exclusiveMinimum?: boolean;
+};
+export type BasedNumberDisplay = NumberFormat;
+export type BasedTimestampDisplay = DateFormat;
+export type BasedSchemaFieldString = {
+    type: 'string';
+} & BasedSchemaFieldShared & BasedSchemaStringShared;
+export type BasedSchemaFieldEnum = {
+    enum: any[];
+    type?: '';
+} & BasedSchemaFieldShared;
+export type BasedSchemaFieldCardinality = {
+    type: 'cardinality';
+} & BasedSchemaFieldShared;
+export type BasedSchemaFieldNumber = NumberDefaults & {
+    type: 'number';
+    display?: BasedNumberDisplay;
+} & BasedSchemaFieldShared;
+export type BasedSchemaFieldInteger = NumberDefaults & {
+    type: 'integer';
+    display?: BasedNumberDisplay;
+} & BasedSchemaFieldShared;
+export type BasedSchemaFieldTimeStamp = NumberDefaults & {
+    type: 'timestamp';
+    display?: BasedTimestampDisplay;
+} & BasedSchemaFieldShared;
+export type BasedSchemaFieldBoolean = {
+    type: 'boolean';
+} & BasedSchemaFieldShared;
+export type BasedSchemaFieldJSON = {
+    type: 'json';
+} & BasedSchemaFieldShared;
+export type BasedSchemaFieldPrimitive = BasedSchemaFieldString | BasedSchemaFieldNumber | BasedSchemaFieldInteger | BasedSchemaFieldTimeStamp | BasedSchemaFieldJSON | BasedSchemaFieldBoolean | BasedSchemaFieldEnum;
+export type BasedSchemaFieldText = {
+    type: 'text';
+    required?: BasedSchemaLanguage[];
+} & BasedSchemaFieldShared & BasedSchemaStringShared;
+export type BasedSchemaFieldObject = {
+    type: 'object';
+    properties: {
+        [name: string]: BasedSchemaField;
+    };
+    required?: string[];
+} & BasedSchemaFieldShared;
+export type BasedSchemaFieldRecord = {
+    type: 'record';
+    values: BasedSchemaField;
+} & BasedSchemaFieldShared;
+export type BasedSchemaFieldArray = {
+    type: 'array';
+    values: BasedSchemaField;
+} & BasedSchemaFieldShared;
+export type BasedSchemaFieldSet = {
+    type: 'set';
+    items: BasedSchemaFieldPrimitive;
+} & BasedSchemaFieldShared;
+export type BasedSchemaFieldEnumerable = BasedSchemaFieldText | BasedSchemaFieldObject | BasedSchemaFieldRecord | BasedSchemaFieldArray | BasedSchemaFieldSet;
+export type BasedSchemaFieldReference = {
+    type: 'reference';
+    bidirectional?: {
+        fromField: string;
+    };
+    allowedTypes?: AllowedTypes;
+} & BasedSchemaFieldShared;
+export type BasedSchemaFieldReferences = {
+    type: 'references';
+    bidirectional?: {
+        fromField: string;
+    };
+    allowedTypes?: AllowedTypes;
+} & BasedSchemaFieldShared;
+export type BasedSchemaFields = {
+    string: BasedSchemaFieldString;
+    number: BasedSchemaFieldNumber;
+    integer: BasedSchemaFieldInteger;
+    timestamp: BasedSchemaFieldTimeStamp;
+    json: BasedSchemaFieldJSON;
+    boolean: BasedSchemaFieldBoolean;
+    enum: BasedSchemaFieldEnum;
+    array: BasedSchemaFieldArray;
+    object: BasedSchemaFieldObject;
+    set: BasedSchemaFieldSet;
+    record: BasedSchemaFieldRecord;
+    reference: BasedSchemaFieldReference;
+    references: BasedSchemaFieldReferences;
+    text: BasedSchemaFieldText;
+    cardinality: BasedSchemaFieldCardinality;
+};
+export type BasedSchemaField = BasedSchemaFields[keyof BasedSchemaFields] | (BasedSchemaFieldShared & {
+    type?: '';
+    isRequired?: boolean;
+    $ref: string;
+});
+export type BasedSchemaType = {
+    fields: {
+        [name: string]: BasedSchemaField;
+    };
+    title?: string;
+    description?: string;
+    prefix?: BasedSchemaTypePrefix;
+    examples?: any[];
+    required?: string[];
+    $defs?: {
+        [key: string]: BasedSchemaField;
+    };
+    $delete?: boolean;
+};
+export type BasedSchema = {
+    language: BasedSchemaLanguage;
+    translations?: BasedSchemaLanguage[];
+    languageFallbacks?: Partial<Record<BasedSchemaLanguage, BasedSchemaLanguage[]>>;
+    root: BasedSchemaType;
+    $defs: {
+        [name: string]: BasedSchemaField;
+    };
+    types: {
+        [type: string]: BasedSchemaType;
+    };
+    prefixToTypeMapping: {
+        [prefix: string]: string;
+    };
+};
+export type BasedSchemaTypePartial = PartialDeep<BasedSchemaType>;
+export type BasedSchemaFieldPartial = PartialDeep<BasedSchemaField>;
+export type BasedSchemaPartial = PartialDeep<BasedSchema>;
+export type BasedSetTarget = {
+    type: string;
+    $alias?: string;
+    $id?: string;
+    schema: BasedSchema;
+    $merge?: boolean;
+    $language?: BasedSchemaLanguage;
+    required: (number | string)[][];
+    collected: BasedSchemaCollectProps[];
+    errors: {
+        code: ParseError;
+        path: Path;
+    }[];
+};
+export type BasedSchemaCollectProps = ArgsClass<BasedSetTarget> & {
+    root: ArgsClass<BasedSetTarget> & {
+        typeSchema: BasedSchemaType;
+    };
+};
+export {};

package/dist/types.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.languages = exports.isCollection = exports.basedSchemaFieldTypes = void 0;
+const languages_1 = require("./languages");
+exports.basedSchemaFieldTypes = [
+    'array',
+    'object',
+    'record',
+    'set',
+    'string',
+    'boolean',
+    'number',
+    'json',
+    'integer',
+    'timestamp',
+    'reference',
+    'references',
+    'text',
+    'enum',
+    'cardinality',
+];
+const isCollection = (type) => {
+    return type === 'array' || type === 'object' || type === 'record';
+};
+exports.isCollection = isCollection;
+exports.languages = Object.keys(languages_1.languages);
+//# sourceMappingURL=types.js.map

package/dist/updateSchema.d.ts

@@ -0,0 +1,2 @@
+import { BasedSchema, BasedSchemaPartial } from './types';
+export declare const updateSchema: (newSchema: BasedSchemaPartial, oldSchema?: BasedSchema) => Promise<BasedSchema>;

package/dist/updateSchema.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateSchema = void 0;
+const updateSchema = async (newSchema, oldSchema = {
+    $defs: {},
+    types: {},
+    language: 'en',
+    root: { fields: {} },
+    prefixToTypeMapping: {},
+}) => {
+    // add sha
+    // put isRequired on the new schema in REQUIRED arrays
+    return oldSchema;
+};
+exports.updateSchema = updateSchema;
+//# sourceMappingURL=updateSchema.js.map

package/dist/validateSchema.d.ts

@@ -0,0 +1,4 @@
+import { BasedSchemaPartial, BasedSchemaFieldPartial, BasedSchemaTypePartial } from './types';
+export declare const validateType: (fromSchema: BasedSchemaPartial, typeName: string, type: BasedSchemaTypePartial) => void;
+export declare const validateField: (fromSchema: BasedSchemaPartial, path: string[], field: BasedSchemaFieldPartial) => void;
+export declare const validateSchema: (schema: BasedSchemaPartial) => BasedSchemaPartial;

package/dist/validateSchema.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSchema = exports.validateField = exports.validateType = void 0;
+// gaurd in the schema for refs in arrays
+const validateType = (fromSchema, typeName, type) => {
+    if (type.prefix &&
+        (typeof type.prefix !== 'string' || type.prefix.length !== 2)) {
+        throw new Error(`Incorrect prefix "${type.prefix}" for type "${typeName}" has to be a string of 2 alphanumerical characters e.g. "Az", "ab", "cc", "10"`);
+    }
+};
+exports.validateType = validateType;
+const validateField = (fromSchema, path, field) => {
+    //
+};
+exports.validateField = validateField;
+const validateSchema = (schema) => {
+    // rewrite schema things like required / required: []
+    if (typeof schema !== 'object') {
+        throw new Error('Schema is not an object');
+    }
+    if (schema.language && typeof schema.language !== 'string') {
+        throw new Error('Language must be a string');
+    }
+    if (schema.translations && !Array.isArray(schema.translations)) {
+        throw new Error('Translations needs to be an array');
+    }
+    if (schema.$defs) {
+        // first defs ofc
+    }
+    if (schema.root) {
+        (0, exports.validateType)(schema, 'root', schema.root);
+    }
+    if (schema.types) {
+        for (const type in schema.types) {
+            (0, exports.validateType)(schema, type, schema.types[type]);
+        }
+    }
+    return schema;
+};
+exports.validateSchema = validateSchema;
+//# sourceMappingURL=validateSchema.js.map

package/dist/walker/args.d.ts

@@ -0,0 +1,36 @@
+import { BasedSchema } from '../types';
+import { BasedSchemaType, BasedSchemaFields } from '../types';
+import { ArgsOpts, Path, Opts, Stopped, Collect } from './types';
+import { ParseError } from '../error';
+export declare class ArgsClass<T, K extends keyof BasedSchemaFields = keyof BasedSchemaFields> {
+    errors: any[];
+    id: number;
+    prev: ArgsClass<T, K>;
+    root: ArgsClass<T, K>;
+    _opts: Opts<T>;
+    _target: T;
+    _stopObject?: boolean;
+    _schema: BasedSchema;
+    parseTopLevel?: boolean;
+    _collectOverride: Collect<T>;
+    fieldSchema?: BasedSchemaFields[K];
+    typeSchema?: BasedSchemaType;
+    path: Path;
+    skipCollection: boolean;
+    value: any;
+    stopped: Stopped | void;
+    fromBackTrack: any[];
+    collectedCommands: any[];
+    constructor(opts: ArgsOpts<T, K>, prev?: ArgsClass<T, K>);
+    get schema(): BasedSchema;
+    get key(): number | string;
+    get target(): T;
+    stop(onllyStopFieldSchemaParser?: boolean): void;
+    create(opts?: ArgsOpts<T>): ArgsClass<T>;
+    parse(opts?: ArgsOpts<T>): Promise<ArgsClass<T> | void>;
+    getTopPaths(): Path[];
+    getBackTrackTarget(): ArgsClass<T>;
+    getCollectTarget(): void;
+    collect(value?: any): void;
+    error(code: ParseError): void;
+}

package/dist/walker/args.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArgsClass = void 0;
+const types_1 = require("./types");
+const parse_1 = require("./parse");
+const utils_1 = require("@saulx/utils");
+let id = 0;
+class ArgsClass {
+    constructor(opts, prev) {
+        this.id = ++id;
+        this.fromBackTrack = [];
+        this.collectedCommands = [];
+        if (opts.prev) {
+            prev = opts.prev;
+        }
+        if (opts.parseTopLevel) {
+            this.parseTopLevel = opts.parseTopLevel;
+        }
+        if (prev) {
+            this.prev = prev;
+            this.root = prev.root;
+            this.fieldSchema = prev.fieldSchema;
+        }
+        if (opts.path) {
+            this.path = opts.path;
+        }
+        else if (prev && opts.key !== undefined) {
+            this.path = [...prev.path, opts.key];
+        }
+        else if (opts && prev) {
+            this.path = prev.path;
+        }
+        else {
+            this.path = [];
+        }
+        this.value = opts.value;
+        if (opts.fieldSchema) {
+            // @ts-ignore K is too loose
+            this.fieldSchema = opts.fieldSchema;
+        }
+        if (opts.typeSchema) {
+            this.typeSchema = opts.typeSchema;
+        }
+        if (opts.target) {
+            this._target = opts.target;
+        }
+        if (opts.collect) {
+            this._collectOverride = opts.collect;
+        }
+        else if (prev?._collectOverride) {
+            this._collectOverride = prev._collectOverride;
+        }
+        if (opts.skipCollection) {
+            this.skipCollection = opts.skipCollection;
+        }
+        else if (prev?.skipCollection) {
+            this.skipCollection = true;
+        }
+    }
+    get schema() {
+        if (this._schema) {
+            return this.schema;
+        }
+        return this.root._schema;
+    }
+    get key() {
+        return this.path[this.path.length - 1] ?? '';
+    }
+    get target() {
+        if (this._target) {
+            return this._target;
+        }
+        let p = this.prev;
+        while (p) {
+            if (p._target) {
+                return p._target;
+            }
+            p = p.prev;
+        }
+    }
+    stop(onllyStopFieldSchemaParser) {
+        const target = this;
+        if (onllyStopFieldSchemaParser) {
+            target.stopped = types_1.Stopped.onlyStopFieldParser;
+        }
+        else {
+            target.stopped = types_1.Stopped.stopAll;
+        }
+    }
+    create(opts) {
+        const newArgs = new ArgsClass(opts, this);
+        if (this._collectOverride && !opts.collect) {
+            newArgs._collectOverride = this._collectOverride;
+        }
+        if (this.skipCollection && opts.skipCollection !== false) {
+            newArgs.skipCollection = this.skipCollection;
+        }
+        if (!('value' in opts)) {
+            newArgs.value = this.value;
+        }
+        return newArgs;
+    }
+    async parse(opts) {
+        if (!opts) {
+            return (0, parse_1.parse)(this);
+        }
+        else {
+            const newArgs = new ArgsClass(opts, this);
+            if (newArgs.value === undefined) {
+                newArgs.value = this.value;
+            }
+            return newArgs.parse();
+        }
+    }
+    getTopPaths() {
+        let argPath = [];
+        let p = this;
+        while (p) {
+            argPath.unshift({ path: p.path, id: p.id });
+            // @ts-ignore
+            p = p.prev;
+        }
+        return argPath;
+    }
+    getBackTrackTarget() {
+        let p = this;
+        while (p) {
+            if (p.prev) {
+                if ((0, utils_1.deepEqual)(p.prev.path, p.path)) {
+                    p = p.prev;
+                }
+                else {
+                    p = p.prev;
+                    break;
+                }
+            }
+            else {
+                break;
+            }
+        }
+        return p;
+    }
+    getCollectTarget() { }
+    collect(value) {
+        if (this.skipCollection) {
+            return;
+        }
+        const collectArgs = value !== undefined ? new ArgsClass({ value }, this) : this;
+        let collectTarget = this.prev;
+        if (this._collectOverride) {
+            collectTarget.collectedCommands.push(this._collectOverride(collectArgs));
+        }
+        else {
+            collectTarget.collectedCommands.push(this.root._opts.collect(collectArgs));
+        }
+    }
+    error(code) {
+        this.root._opts.error(code, this);
+    }
+}
+exports.ArgsClass = ArgsClass;
+//# sourceMappingURL=args.js.map

package/dist/walker/index.d.ts

@@ -0,0 +1,6 @@
+import { BasedSchema } from '../types';
+import { ArgsClass } from './args';
+import { AsyncOperation, Opts } from './types';
+export declare const walk: <T>(schema: BasedSchema, opts: Opts<T>, value: any, asyncOperationHandler?: AsyncOperation<T>) => Promise<T>;
+export { ArgsClass };
+export * from './types';

package/dist/walker/index.js

@@ -0,0 +1,49 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArgsClass = exports.walk = void 0;
+const args_1 = require("./args");
+Object.defineProperty(exports, "ArgsClass", { enumerable: true, get: function () { return args_1.ArgsClass; } });
+const walk = async (schema, opts, value, asyncOperationHandler) => {
+    if (!('collect' in opts)) {
+        opts.collect = () => { };
+    }
+    if (!('error' in opts)) {
+        opts.error = () => { };
+    }
+    if (asyncOperationHandler) {
+        opts = {
+            ...opts,
+            asyncOperationHandler,
+        };
+    }
+    const argsOpts = await opts.init(value, schema, opts.error);
+    if (!argsOpts) {
+        return {};
+    }
+    if (!argsOpts.value) {
+        argsOpts.value = value;
+    }
+    const args = new args_1.ArgsClass(argsOpts);
+    args.root = args;
+    args._opts = opts;
+    args._schema = schema;
+    await args.parse();
+    return args.target;
+};
+exports.walk = walk;
+__exportStar(require("./types"), exports);
+//# sourceMappingURL=index.js.map

package/dist/walker/parse.d.ts

@@ -0,0 +1,3 @@
+import { ArgsClass } from './args';
+export type ParseResult<T> = ArgsClass<T> | void;
+export declare function parse<T>(args: ArgsClass<T>): Promise<ArgsClass<T> | void>;