@croct/sdk 0.17.9 → 0.17.11

package/src/validation/jsonType.ts

@@ -1,156 +0,0 @@
-import {JsonArray, JsonObject, JsonPrimitive, JsonValue} from '@croct/json';
-import {Schema, TypeSchema, Violation} from './schema';
-import {describe, formatPath} from './violation';
-
-function isJsonPrimitive(value: unknown): value is JsonPrimitive {
-    return value === null || typeof value === 'string' || typeof value === 'boolean' || typeof value === 'number';
-}
-
-function isPlainObject(value: unknown): value is object {
-    return Object.prototype
-        .toString
-        .call(value) === '[object Object]';
-}
-
-function isJsonArray(value: unknown): value is JsonArray {
-    return Array.isArray(value) && value.every(isJsonValue);
-}
-
-function isJsonObject(value: unknown): value is JsonObject {
-    return isPlainObject(value) && Object.values(value).every(isJsonValue);
-}
-
-function isJsonValue(value: unknown): value is JsonValue {
-    return isJsonPrimitive(value) || isJsonArray(value) || isJsonObject(value);
-}
-
-type JsonObjectDefinition = {
-    properties?: Schema,
-    propertyNames?: Schema,
-};
-
-export class JsonObjectType implements TypeSchema {
-    private readonly definition: JsonObjectDefinition;
-
-    public constructor(definition: JsonObjectDefinition = {}) {
-        this.definition = definition;
-    }
-
-    public getTypes(): string[] {
-        return ['object'];
-    }
-
-    public isValidType(value: unknown): boolean {
-        return isPlainObject(value);
-    }
-
-    public validate(value: unknown, path: string[] = []): void {
-        if (!isJsonObject(value)) {
-            throw new Violation(
-                `Expected a JSON object at path '${formatPath(path)}', actual ${describe(value)}.`,
-                path,
-                {type: 'object'},
-            );
-        }
-
-        if (this.definition.properties === undefined && this.definition.propertyNames === undefined) {
-            return;
-        }
-
-        for (const [entryName, entryValue] of Object.entries(value)) {
-            const propertyPath = path.concat([entryName]);
-
-            if (this.definition.propertyNames !== undefined) {
-                this.definition
-                    .propertyNames
-                    .validate(entryName, propertyPath);
-            }
-
-            if (this.definition.properties !== undefined) {
-                this.definition
-                    .properties
-                    .validate(entryValue, path.concat([entryName]));
-            }
-        }
-    }
-}
-
-type JsonArrayDefinition = {
-    items?: Schema,
-};
-
-export class JsonArrayType implements TypeSchema {
-    private readonly definition: JsonArrayDefinition;
-
-    public constructor(definition: JsonArrayDefinition = {}) {
-        this.definition = definition;
-    }
-
-    public getTypes(): string[] {
-        return ['array'];
-    }
-
-    public isValidType(value: unknown): boolean {
-        return Array.isArray(value);
-    }
-
-    public validate(value: unknown, path: string[] = []): void {
-        if (!isJsonArray(value)) {
-            throw new Violation(
-                `Expected a JSON array at path '${formatPath(path)}', actual ${describe(value)}.`,
-                path,
-                {type: 'array'},
-            );
-        }
-
-        if (this.definition.items === undefined) {
-            return;
-        }
-
-        for (let index = 0; index < value.length; index++) {
-            this.definition
-                .items
-                .validate(value[index], path.concat([index.toString()]));
-        }
-    }
-}
-
-export class JsonPrimitiveType implements TypeSchema {
-    public getTypes(): string[] {
-        return ['null', 'number', 'string', 'boolean'];
-    }
-
-    public isValidType(value: unknown): boolean {
-        return isJsonPrimitive(value);
-    }
-
-    public validate(value: unknown, path: string[] = []): void {
-        if (!this.isValidType(value)) {
-            throw new Violation(
-                `Expected a JSON primitive at path '${formatPath(path)}', actual ${describe(value)}.`,
-                path,
-                {type: this.getTypes().join('|')},
-            );
-        }
-    }
-}
-
-export class JsonType implements TypeSchema {
-    public getTypes(): string[] {
-        return ['null', 'number', 'string', 'boolean', 'array', 'object'];
-    }
-
-    public isValidType(value: unknown): boolean {
-        return isJsonPrimitive(value) || Array.isArray(value) || isPlainObject(value);
-    }
-
-    public validate(value: unknown, path: string[] = []): void {
-        if (!isJsonValue(value)) {
-            throw new Violation(
-                `Expected a JSON value at path '${formatPath(path)}', actual ${describe(value)}.`,
-                path,
-                {type: this.getTypes().join('|')},
-            );
-        }
-    }
-}

package/src/validation/mixedSchema.ts

@@ -1,7 +0,0 @@
-import {Schema} from './schema';
-
-export class MixedSchema implements Schema {
-    public validate(): void {
-        // always valid
-    }
-}

package/src/validation/nullType.ts

@@ -1,22 +0,0 @@
-import {TypeSchema, Violation} from './schema';
-import {describe, formatPath} from './violation';
-
-export class NullType implements TypeSchema {
-    public getTypes(): string[] {
-        return ['null'];
-    }
-
-    public isValidType(value: unknown): value is null {
-        return value === null;
-    }
-
-    public validate(value: unknown, path: string[] = []): void {
-        if (!this.isValidType(value)) {
-            throw new Violation(
-                `Expected value of type null at path '${formatPath(path)}', actual ${describe(value)}.`,
-                path,
-                {type: 'null'},
-            );
-        }
-    }
-}

package/src/validation/numberType.ts

@@ -1,59 +0,0 @@
-import {TypeSchema, Violation} from './schema';
-import {describe, formatPath} from './violation';
-
-type NumberDefinition = {
-    integer: boolean,
-    minimum: number,
-    maximum: number,
-};
-
-export class NumberType implements TypeSchema {
-    private readonly definition: NumberDefinition;
-
-    public constructor(definition: Partial<NumberDefinition> = {}) {
-        this.definition = {
-            ...definition,
-            integer: definition.integer ?? false,
-            minimum: definition.minimum ?? Number.NEGATIVE_INFINITY,
-            maximum: definition.maximum ?? Number.POSITIVE_INFINITY,
-        };
-    }
-
-    public getTypes(): string[] {
-        return [this.definition.integer ? 'integer' : 'number'];
-    }
-
-    public isValidType(value: unknown): value is number {
-        return typeof value === 'number' && (!this.definition.integer || Number.isInteger(value));
-    }
-
-    public validate(value: unknown, path: string[] = []): void {
-        if (!this.isValidType(value)) {
-            const type = this.getTypes()[0];
-
-            throw new Violation(
-                `Expected value of type ${type} at path '${formatPath(path)}', actual ${describe(value)}.`,
-                path,
-                {type: type},
-            );
-        }
-
-        if (value < this.definition.minimum) {
-            throw new Violation(
-                `Expected a value greater than or equal to ${this.definition.minimum} `
-                + `at path '${formatPath(path)}', actual ${value}.`,
-                path,
-                {limit: this.definition.minimum},
-            );
-        }
-
-        if (value > this.definition.maximum) {
-            throw new Violation(
-                `Expected a value less than or equal to ${this.definition.maximum} `
-                + `at path '${formatPath(path)}', actual ${value}.`,
-                path,
-                {limit: this.definition.maximum},
-            );
-        }
-    }
-}

package/src/validation/objectType.ts

@@ -1,138 +0,0 @@
-import {Schema, TypeSchema, Violation} from './schema';
-import {MixedSchema} from './mixedSchema';
-import {describe, formatPath} from './violation';
-
-type ObjectDefinition = {
-    type?: {new (...args: any): any},
-    properties: {[key: string]: Schema},
-    additionalProperties: boolean | Schema,
-    subtypes?: {
-        discriminator: string,
-        schemas: {[key: string]: ObjectType},
-    },
-    propertyNames: Schema,
-    required: string[],
-    minProperties: number,
-    maxProperties: number,
-};
-
-export class ObjectType implements TypeSchema {
-    private readonly definition: ObjectDefinition;
-
-    public constructor(schema: Partial<ObjectDefinition> = {}) {
-        this.definition = {
-            ...schema,
-            properties: schema.properties ?? {},
-            required: schema.required ?? [],
-            additionalProperties: schema.additionalProperties ?? false,
-            propertyNames: schema.propertyNames ?? new MixedSchema(),
-            minProperties: schema.minProperties ?? -1,
-            maxProperties: schema.maxProperties ?? -1,
-        };
-    }
-
-    public getTypes(): string[] {
-        if (this.definition.type !== undefined) {
-            return [this.definition.type.name];
-        }
-
-        return ['object'];
-    }
-
-    public isValidType(value: unknown): value is object {
-        if (this.definition.type !== undefined) {
-            return value instanceof this.definition.type;
-        }
-
-        return Object.prototype
-            .toString
-            .call(value) === '[object Object]';
-    }
-
-    public validate(value: unknown, path: string[] = []): void {
-        if (!this.isValidType(value)) {
-            const [type] = this.getTypes();
-
-            throw new Violation(
-                `Expected value of type ${type} at path '${formatPath(path)}', `
-                + `actual ${describe(value)}.`,
-                path,
-                {type: type},
-            );
-        }
-
-        const entries = Object.entries(value);
-
-        const {minProperties, maxProperties} = this.definition;
-
-        if (minProperties >= 0 && minProperties > entries.length) {
-            throw new Violation(
-                `Expected ${minProperties === maxProperties ? 'exactly' : 'at least'} `
-                + `${minProperties} ${minProperties === 1 ? 'entry' : 'entries'} `
-                + `at path '${formatPath(path)}', actual ${entries.length}.`,
-                path,
-                {limit: minProperties},
-            );
-        }
-
-        if (maxProperties >= 0 && maxProperties < entries.length) {
-            throw new Violation(
-                `Expected ${minProperties === maxProperties ? 'exactly' : 'at most'} `
-                + `${maxProperties} ${maxProperties === 1 ? 'entry' : 'entries'} `
-                + `at path '${formatPath(path)}', actual ${entries.length}.`,
-                path,
-                {limit: maxProperties},
-            );
-        }
-
-        const additionalProperties: {[key: string]: any} = {...value};
-
-        for (const property of this.definition.required) {
-            if (!(property in value)) {
-                throw new Violation(`Missing property '${formatPath(path.concat([property]))}'.`, path, {
-                    required: property,
-                });
-            }
-        }
-
-        for (const [entryName, entryValue] of entries) {
-            const propertyPath = path.concat([entryName]);
-
-            this.definition
-                .propertyNames
-                .validate(entryName, propertyPath);
-
-            const propertyRule = this.definition.properties[entryName];
-
-            if (propertyRule !== undefined) {
-                propertyRule.validate(entryValue, propertyPath);
-
-                delete additionalProperties[entryName];
-
-                continue;
-            }
-
-            if (this.definition.additionalProperties === false) {
-                throw new Violation(`Unknown property '${formatPath(propertyPath)}'.`, propertyPath, {
-                    additionalProperty: entryName,
-                });
-            }
-
-            if (this.definition.additionalProperties !== true) {
-                this.definition
-                    .additionalProperties
-                    .validate(entryValue, propertyPath);
-            }
-        }
-
-        const {subtypes} = this.definition;
-
-        if (subtypes !== undefined) {
-            const type = (value as any)[subtypes.discriminator];
-
-            if (type !== undefined && subtypes.schemas[type] !== undefined) {
-                subtypes.schemas[type].validate(additionalProperties, path);
-            }
-        }
-    }
-}

package/src/validation/schema.ts

@@ -1,21 +0,0 @@
-export interface Schema {
-    validate(value: unknown, path?: string[]): void;
-}
-
-export interface TypeSchema extends Schema {
-    getTypes(): string[];
-
-    isValidType(value: unknown): boolean;
-}
-
-export class Violation extends Error {
-    public readonly path: string[];
-
-    public readonly params: {[key: string]: unknown};
-
-    public constructor(message: string, path: string[], params: {[p: string]: unknown}) {
-        super(message);
-        this.path = path;
-        this.params = params;
-    }
-}

package/src/validation/stringType.ts

@@ -1,118 +0,0 @@
-import {TypeSchema, Violation} from './schema';
-import {describe, formatPath} from './violation';
-
-interface Format {
-    (value: string): boolean;
-}
-
-const FORMAT: {[key: string]: Format} = {
-    pointer: function pointer(value: string): boolean {
-        return /^(\.|([a-zA-Z_][a-zA-Z0-9_]*|\[[0-9]+])(\.[a-zA-Z_][a-zA-Z0-9_]*|\[[0-9]+])*)$/.test(value);
-    },
-    identifier: function identifier(value: string): boolean {
-        return /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(value);
-    },
-    uuid: function uuid(value: string): boolean {
-        return /^[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/.test(value);
-    },
-    date: function date(value: string): boolean {
-        return /^(\d\d\d\d)-(\d\d)-(\d\d)$/.test(value);
-    },
-    url: function url(value: string): boolean {
-        try {
-            // eslint-disable-next-line no-new -- Easier way to validate a URL
-            new URL(value);
-        } catch {
-            return false;
-        }
-
-        return true;
-    },
-};
-
-type StringDefinition = {
-    minLength: number,
-    maxLength: number,
-    enumeration: string[],
-    pattern?: RegExp,
-    format?: keyof typeof FORMAT,
-};
-
-export class StringType implements TypeSchema {
-    private readonly definition: StringDefinition;
-
-    public constructor(definition: Partial<StringDefinition> = {}) {
-        this.definition = {
-            ...definition,
-            minLength: definition.minLength ?? -1,
-            maxLength: definition.maxLength ?? -1,
-            enumeration: definition.enumeration ?? [],
-        };
-    }
-
-    public getTypes(): string[] {
-        return ['string'];
-    }
-
-    public isValidType(value: unknown): value is string {
-        return typeof value === 'string';
-    }
-
-    public validate(value: unknown, path: string[] = []): void {
-        if (!this.isValidType(value)) {
-            throw new Violation(
-                `Expected value of type string at path '${formatPath(path)}', actual ${describe(value)}.`,
-                path,
-                {type: 'string'},
-            );
-        }
-
-        const {minLength, maxLength} = this.definition;
-
-        if (minLength >= 0 && minLength > value.length) {
-            throw new Violation(
-                `Expected ${minLength === maxLength ? 'exactly' : 'at least'} `
-                + `${minLength} ${minLength === 1 ? 'character' : 'characters'} `
-                + `at path '${formatPath(path)}', actual ${value.length}.`,
-                path,
-                {limit: minLength},
-            );
-        }
-
-        if (maxLength >= 0 && maxLength < value.length) {
-            throw new Violation(
-                `Expected ${minLength === maxLength ? 'exactly' : 'at most'} `
-                + `${maxLength} ${maxLength === 1 ? 'character' : 'characters'} `
-                + `at path '${formatPath(path)}', actual ${value.length}.`,
-                path,
-                {limit: maxLength},
-            );
-        }
-
-        const {enumeration} = this.definition;
-
-        if (enumeration.length > 0 && enumeration.indexOf(value) < 0) {
-            throw new Violation(
-                `Unexpected value at path '${formatPath(path)}', expecting `
-                + `'${
-                    enumeration.length === 1
-                        ? enumeration[0]
-                        : `${enumeration.slice(0, -1).join('\', \'')}' or '${enumeration.slice(-1)}`
-                }', `
-                + `found '${value}'.`,
-                path,
-                {enumeration: enumeration},
-            );
-        }
-
-        const {format, pattern} = this.definition;
-
-        if (format !== undefined && !FORMAT[format](value)) {
-            throw new Violation(`Invalid ${format} format at path '${formatPath(path)}'.`, path, {format: format});
-        }
-
-        if (pattern !== undefined && !pattern.test(value)) {
-            throw new Violation(`Invalid format at path '${formatPath(path)}'.`, path, {pattern: pattern});
-        }
-    }
-}

package/src/validation/unionType.ts

@@ -1,53 +0,0 @@
-import {TypeSchema, Violation} from './schema';
-import {describe, formatPath} from './violation';
-
-export class UnionType implements TypeSchema {
-    private readonly schemas: TypeSchema[];
-
-    public constructor(first: TypeSchema, second: TypeSchema, ...others: TypeSchema[]) {
-        this.schemas = [first, second, ...others];
-    }
-
-    public getTypes(): string[] {
-        const types = [];
-
-        for (const schema of this.schemas) {
-            for (const type of schema.getTypes()) {
-                if (types.indexOf(type) < 0) {
-                    types.push(type);
-                }
-            }
-        }
-
-        return types;
-    }
-
-    public isValidType(value: unknown): boolean {
-        for (const schema of this.schemas) {
-            if (schema.isValidType(value)) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    public validate(value: unknown, path: string[] = []): void {
-        for (const schema of this.schemas) {
-            if (schema.isValidType(value)) {
-                schema.validate(value, path);
-
-                return;
-            }
-        }
-
-        const types = this.getTypes();
-
-        throw new Violation(
-            `Expected value of type ${types.slice(0, -1).join(', ')} or ${types[types.length - 1]} `
-            + `at path '${formatPath(path)}', actual ${describe(value)}.`,
-            path,
-            {type: types.join('|')},
-        );
-    }
-}

package/src/validation/violation.ts

@@ -1,23 +0,0 @@
-export function describe(value: unknown): string {
-    if (value === null) {
-        return 'null';
-    }
-
-    if (Array.isArray(value)) {
-        return 'array';
-    }
-
-    if (typeof value === 'number') {
-        return Number.isInteger(value) ? 'integer' : 'number';
-    }
-
-    if (typeof value === 'object') {
-        return (value as object).constructor.name;
-    }
-
-    return typeof value;
-}
-
-export function formatPath(path: string[]): string {
-    return `/${path.join('/')}`;
-}