@croct/sdk 0.11.0-alpha → 0.11.0-alpha.2

package/src/validation/jsonType.ts

@@ -0,0 +1,157 @@
+/* eslint-disable @typescript-eslint/no-use-before-define -- Mutual dependency */
+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

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

package/src/validation/nullType.ts

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,138 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,118 @@
+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

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,23 @@
+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('/')}`;
+}

package/tab.js

@@ -93,3 +93,4 @@ class Tab {
     }
 }
 exports.Tab = Tab;
+//# sourceMappingURL=tab.js.map

package/tab.js.map

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

package/token/cachedTokenStore.js

@@ -27,3 +27,4 @@ class CachedTokenStore {
     }
 }
 exports.CachedTokenStore = CachedTokenStore;
+//# sourceMappingURL=cachedTokenStore.js.map

package/token/cachedTokenStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cachedTokenStore.js","sourceRoot":"","sources":["../src/token/cachedTokenStore.ts"],"names":[],"mappings":";;;AAAA,mCAA0C;AAG1C,MAAa,gBAAgB;IAGzB,YAAmB,KAAY;QAC3B,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACvB,CAAC;IAEM,QAAQ;QACX,MAAM,IAAI,GAAkB,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC;QAE7C,IAAI,IAAI,KAAK,IAAI,EAAE;YACf,OAAO,IAAI,CAAC;SACf;QAED,IAAI;YACA,OAAO,aAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;SAC5B;QAAC,OAAO,KAAK,EAAE;YACZ,OAAO,IAAI,CAAC;SACf;IACL,CAAC;IAEM,QAAQ,CAAC,KAAmB;QAC/B,IAAI,KAAK,KAAK,IAAI,EAAE;YAChB,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;YAEnB,OAAO;SACV;QAED,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;IACrC,CAAC;CACJ;AA9BD,4CA8BC"}

package/token/inMemoryTokenStore.js

@@ -13,3 +13,4 @@ class InMemoryTokenStore {
     }
 }
 exports.InMemoryTokenStore = InMemoryTokenStore;
+//# sourceMappingURL=inMemoryTokenStore.js.map

package/token/inMemoryTokenStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inMemoryTokenStore.js","sourceRoot":"","sources":["../src/token/inMemoryTokenStore.ts"],"names":[],"mappings":";;;AAEA,MAAa,kBAAkB;IAA/B;QACY,UAAK,GAAiB,IAAI,CAAC;IASvC,CAAC;IAPU,QAAQ;QACX,OAAO,IAAI,CAAC,KAAK,CAAC;IACtB,CAAC;IAEM,QAAQ,CAAC,KAAmB;QAC/B,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACvB,CAAC;CACJ;AAVD,gDAUC"}

package/token/index.js

@@ -9,3 +9,4 @@ var inMemoryTokenStore_1 = require("./inMemoryTokenStore");
 Object.defineProperty(exports, "InMemoryTokenStore", { enumerable: true, get: function () { return inMemoryTokenStore_1.InMemoryTokenStore; } });
 var replicatedTokenStore_1 = require("./replicatedTokenStore");
 Object.defineProperty(exports, "ReplicatedTokenStore", { enumerable: true, get: function () { return replicatedTokenStore_1.ReplicatedTokenStore; } });
+//# sourceMappingURL=index.js.map

package/token/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/token/index.ts"],"names":[],"mappings":";;;;AAAA,kDAAwB;AACxB,uDAAoD;AAA5C,oHAAA,gBAAgB,OAAA;AACxB,2DAAwD;AAAhD,wHAAA,kBAAkB,OAAA;AAC1B,+DAA4D;AAApD,4HAAA,oBAAoB,OAAA"}

package/token/replicatedTokenStore.js

@@ -15,3 +15,4 @@ class ReplicatedTokenStore {
     }
 }
 exports.ReplicatedTokenStore = ReplicatedTokenStore;
+//# sourceMappingURL=replicatedTokenStore.js.map

package/token/replicatedTokenStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"replicatedTokenStore.js","sourceRoot":"","sources":["../src/token/replicatedTokenStore.ts"],"names":[],"mappings":";;;AAEA,MAAa,oBAAoB;IAK7B,YAAmB,OAAmB,EAAE,SAAqB;QACzD,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC/B,CAAC;IAEM,QAAQ;QACX,OAAO,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC;IACnC,CAAC;IAEM,QAAQ,CAAC,KAAmB;QAC/B,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QAC7B,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IACnC,CAAC;CACJ;AAlBD,oDAkBC"}

package/token/token.js

@@ -103,3 +103,4 @@ class FixedTokenProvider {
     }
 }
 exports.FixedTokenProvider = FixedTokenProvider;
+//# sourceMappingURL=token.js.map

package/token/token.js.map

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

package/tracker.js

@@ -310,3 +310,4 @@ class Tracker {
     }
 }
 exports.Tracker = Tracker;
+//# sourceMappingURL=tracker.js.map