gingersnap 0.22.0

package/data/model/property.mjs

@@ -0,0 +1,278 @@
+import * as R from 'ramda';
+import { namespacedModelInternalProps, Optional, Model } from './model.mjs';
+import { InvalidType } from '../../errors/InvalidType.mjs';
+import { InvalidValue } from '../../errors/InvalidValue.mjs';
+import { DataType } from './types.mjs';
+
+/**
+ * Creates a decorator that updates a field
+ * @param functor updater function
+ * @returns a decorator
+ */
+const createFieldUpdater = (functor) => (target, key) => {
+    var _a;
+    const props = (_a = namespacedModelInternalProps.get(target.constructor.name)) !== null && _a !== void 0 ? _a : {
+        fields: new Map(),
+    };
+    const field = R.find((v) => v === key, Array.from(props.fields.keys()));
+    if (!field) {
+        throw new Error(`No field found that matches ${key}`);
+    }
+    functor({ field: props.fields.get(field), target, key });
+    props.parent = Object.getPrototypeOf(target).constructor.name;
+    namespacedModelInternalProps.set(target.constructor.name, props);
+};
+/**
+ * Creates a validator decorator
+ * @param functor validation function
+ * @param error error to be thrown when validation fails
+ * @param updater optional argument to update the current field
+ * @returns a decorator
+ */
+const createValidator = (functor, error, updater) => createFieldUpdater(({ field, target, key }) => {
+    const symbol = Symbol(key);
+    Object.defineProperty(target, key, {
+        get: function () {
+            return this[symbol];
+        },
+        set: function (v) {
+            if (v instanceof Optional) {
+                if (v.isPresent()) {
+                    v = v.get();
+                }
+                else {
+                    this[symbol] = v;
+                    return;
+                }
+            }
+            if (!functor(v))
+                throw error;
+            this[symbol] = v;
+        },
+    });
+    if (updater)
+        updater(field);
+});
+/**
+ * A property that exist in the incoming data
+ * @param name Name of the property in the incoming data. If not provided, the variable name will be assumed as the
+ * property name
+ * @param type type of the field. Not required (useful when the field is an Optional)
+ * @constructor
+ */
+const Field = (name, type = undefined) => (target, key) => {
+    var _a, _b, _c, _d;
+    const schema = {};
+    const props = (_a = namespacedModelInternalProps.get(target.constructor.name)) !== null && _a !== void 0 ? _a : {
+        fields: new Map(),
+    };
+    const dtype = Reflect.getMetadata("design:type", target, key);
+    const fieldProp = (_b = props.fields.get(key)) !== null && _b !== void 0 ? _b : {};
+    if (type && dtype === Optional) {
+        schema.options = { useOptionalObj: true };
+        fieldProp.ignore = Object.assign(Object.assign({}, ((_c = fieldProp.ignore) !== null && _c !== void 0 ? _c : {})), { deserialize: true });
+    }
+    else if (!type) {
+        type = dtype;
+    }
+    else if (!(dtype instanceof type)) {
+        throw new InvalidType(`Type mismatch for property ${key}`);
+    }
+    if (type instanceof Number) {
+        schema.dataType = DataType.DOUBLE;
+    }
+    else if (type instanceof String) {
+        schema.dataType = DataType.STRING;
+    }
+    else if (type instanceof Boolean) {
+        schema.dataType = DataType.BOOLEAN;
+    }
+    else if (type instanceof Model) {
+        schema.dataType = DataType.RECORD;
+        schema.options = Object.assign(Object.assign({}, ((_d = schema.options) !== null && _d !== void 0 ? _d : {})), { recordClass: type });
+    }
+    fieldProp.name = name !== null && name !== void 0 ? name : key;
+    fieldProp.Type = type;
+    fieldProp.isArray = false;
+    fieldProp.schema = schema;
+    props.fields.set(key, fieldProp);
+    if (name) {
+        if (fieldProp.aliases) {
+            fieldProp.aliases.push(name);
+        }
+        else {
+            fieldProp.aliases = [name];
+        }
+    }
+    props.parent = Object.getPrototypeOf(target).constructor.name;
+    namespacedModelInternalProps.set(target.constructor.name, props);
+};
+/**
+ * A property that exists on the incoming data, that contains an array of same data types
+ * @param type Type of data in the array
+ * @param name Name of the property in the incoming data. If not provided, the variable name will be assumed as the
+ * property name
+ * @constructor
+ */
+const ArrayField = (type, name) => (target, key) => {
+    var _a, _b;
+    const props = (_a = namespacedModelInternalProps.get(target.constructor.name)) !== null && _a !== void 0 ? _a : {
+        fields: new Map(),
+    };
+    const schema = { dataType: DataType.ARRAY };
+    const dtype = Reflect.getMetadata("design:type", target, key);
+    const optional = dtype === Optional;
+    schema.options = { useOptionalObj: optional, optional };
+    if (type instanceof Number) {
+        schema.itemType = DataType.DOUBLE;
+    }
+    else if (type instanceof String) {
+        schema.itemType = DataType.STRING;
+    }
+    else if (type instanceof Boolean) {
+        schema.itemType = DataType.BOOLEAN;
+    }
+    else if (type instanceof Model) {
+        schema.options.recordClass = type;
+    }
+    const fieldProp = (_b = props.fields.get(key)) !== null && _b !== void 0 ? _b : {};
+    fieldProp.name = key;
+    fieldProp.Type = type;
+    fieldProp.isArray = true;
+    fieldProp.schema = schema;
+    props.fields.set(key, fieldProp);
+    if (name) {
+        if (fieldProp.aliases) {
+            fieldProp.aliases.push(name);
+        }
+        else {
+            fieldProp.aliases = [name];
+        }
+    }
+    props.parent = Object.getPrototypeOf(target).constructor.name;
+    namespacedModelInternalProps.set(target.constructor.name, props);
+};
+/**
+ * A property that exists on the incoming data, that contains an object/array that can be represented as a hashmap
+ * @param keyType type for the keys in the map
+ * @param valueType type for the values in the map
+ * @param name optional name of the field
+ * @constructor
+ */
+const MapField = (keyType, valueType, name) => (target, key) => {
+    var _a, _b;
+    const props = (_a = namespacedModelInternalProps.get(target.constructor.name)) !== null && _a !== void 0 ? _a : {
+        fields: new Map(),
+    };
+    const schema = { dataType: DataType.MAP };
+    const dtype = Reflect.getMetadata("design:type", target, key);
+    const optional = dtype === Optional;
+    schema.options = { useOptionalObj: optional, optional };
+    const fieldProp = (_b = props.fields.get(key)) !== null && _b !== void 0 ? _b : {};
+    fieldProp.name = key;
+    fieldProp.Type = Map;
+    fieldProp.isMap = true;
+    fieldProp.KeyType = keyType;
+    fieldProp.ValueType = valueType;
+    fieldProp.schema = schema;
+    props.fields.set(key, fieldProp);
+    if (name) {
+        props.fields.set(name, fieldProp);
+    }
+    props.parent = Object.getPrototypeOf(target).constructor.name;
+    namespacedModelInternalProps.set(target.constructor.name, props);
+};
+/**
+ * Alternative name for the associated field
+ * @param name
+ */
+const Alias = (name) => createFieldUpdater(({ field }) => {
+    var _a;
+    const aliases = (_a = field.aliases) !== null && _a !== void 0 ? _a : [];
+    aliases.push(name);
+    field.aliases = aliases;
+});
+/**
+ * Makes the given property only readable
+ * @constructor
+ */
+const Readonly = (target, key) => {
+    var _a, _b;
+    const props = (_a = namespacedModelInternalProps.get(target.constructor.name)) !== null && _a !== void 0 ? _a : {
+        fields: new Map(),
+    };
+    const fieldProps = (_b = props.fields.get(key)) !== null && _b !== void 0 ? _b : {};
+    fieldProps.readonly = true;
+    props.fields.set(key, fieldProps);
+    props.parent = Object.getPrototypeOf(target).constructor.name;
+    namespacedModelInternalProps.set(target.constructor.name, props);
+};
+/**
+ * Validates the value assigned to the associated property
+ * @param matcher functor to check if the assigned value is valid
+ */
+const Validator = (matcher) => createValidator(matcher instanceof Function ? matcher : matcher instanceof RegExp ? (v) => matcher.test(v) : (v) => v === matcher, new InvalidValue(`Invalid value assigned`));
+/**
+ * Raises an error if the field contains an error
+ * @constructor
+ */
+const RaiseError = createFieldUpdater(({ field, target, key }) => {
+    const symbol = Symbol(key);
+    Object.defineProperty(target, key, {
+        get: function () {
+            return this[symbol];
+        },
+        set: function (v) {
+            if (v) {
+                throw v instanceof Error ? v : new Error(v);
+            }
+            this[symbol] = v;
+        },
+    });
+});
+/**
+ * Ignores the annotated field during deserialization (by default) and/or serialization
+ * @param value an object for enabling/disabling which directions should ignore be used
+ * @constructor
+ */
+const Ignore = (value = { serialize: false, deserialize: true }) => createFieldUpdater(({ field }) => {
+    var _a, _b;
+    field.ignore = value;
+    if (value.serialize)
+        delete field.schema;
+    else if (field.schema) {
+        const options = (_b = (_a = field.schema) === null || _a === void 0 ? void 0 : _a.options) !== null && _b !== void 0 ? _b : {};
+        options.optional = true;
+        field.schema.options = options;
+    }
+});
+/**
+ * Registers a schema type for the given field
+ * @param dataType
+ * @param options
+ */
+const SchemaType = (dataType, options) => createFieldUpdater(({ field }) => (field.schema = {
+    dataType,
+    options,
+}));
+/**
+ * Decorator that applies a lower limit validation on a numeric field
+ * @param value limit
+ * @param inclusive should the limit be included. Default is false
+ */
+const LowerBound = (value, inclusive = true) => createValidator(inclusive ? (v) => v >= value : (v) => v > value, new InvalidValue(`value is lower than the minimum value of ${value}`));
+/**
+ * Decorator that applies an upper limit validation on a numeric field
+ * @param value limit
+ * @param inclusive should the limit be included. Default is false
+ */
+const UpperBound = (value, inclusive = false) => createValidator(inclusive ? (v) => v <= value : (v) => v < value, new InvalidValue(`value is higher than the maximum value of ${value}`));
+/**
+ * Decorator that applies a range validation on a numeric field
+ * @param lower lower bound
+ * @param upper upper bound
+ * @param inclusive should the upper bound be included. Default is false
+ */
+const Range = (lower, upper, inclusive = false) => createValidator(inclusive ? (v) => lower <= v && v <= upper : (v) => lower <= v && v < upper, new InvalidValue(`value is not within the range of ${lower} <= v ` + (inclusive ? `<= ${upper}` : `< ${upper}`)));
+
+export { Alias, ArrayField, Field, Ignore, LowerBound, MapField, RaiseError, Range, Readonly, SchemaType, UpperBound, Validator };

package/data/model/types.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+/**
+ * Formatting used with converting data to models
+ */
+exports.DataFormat = void 0;
+(function (DataFormat) {
+    DataFormat[DataFormat["CSV"] = 0] = "CSV";
+    DataFormat[DataFormat["XML"] = 1] = "XML";
+    DataFormat[DataFormat["JSON"] = 2] = "JSON";
+    DataFormat[DataFormat["MESSAGE_PACK"] = 3] = "MESSAGE_PACK";
+})(exports.DataFormat || (exports.DataFormat = {}));
+/**
+ * Supported data types
+ * @beta
+ */
+exports.DataType = void 0;
+(function (DataType) {
+    DataType["RECORD"] = "record";
+    DataType["NULL"] = "null";
+    DataType["BOOLEAN"] = "boolean";
+    DataType["INT"] = "int";
+    DataType["LONG"] = "long";
+    DataType["FLOAT"] = "float";
+    DataType["DOUBLE"] = "double";
+    DataType["BYTES"] = "bytes";
+    DataType["STRING"] = "string";
+    DataType["ENUM"] = "enum";
+    DataType["MAP"] = "map";
+    DataType["FIXED_STRING"] = "fixed";
+    DataType["ARRAY"] = "array";
+})(exports.DataType || (exports.DataType = {}));

package/data/model/types.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Formatting used with converting data to models
+ */
+export declare enum DataFormat {
+    CSV = 0,
+    XML = 1,
+    JSON = 2,
+    MESSAGE_PACK = 3
+}
+/**
+ * Supported data types
+ * @beta
+ */
+export declare enum DataType {
+    RECORD = "record",
+    NULL = "null",
+    BOOLEAN = "boolean",
+    INT = "int",
+    LONG = "long",
+    FLOAT = "float",
+    DOUBLE = "double",
+    BYTES = "bytes",
+    STRING = "string",
+    ENUM = "enum",
+    MAP = "map",
+    FIXED_STRING = "fixed",
+    ARRAY = "array"
+}

package/data/model/types.mjs

@@ -0,0 +1,32 @@
+/**
+ * Formatting used with converting data to models
+ */
+var DataFormat;
+(function (DataFormat) {
+    DataFormat[DataFormat["CSV"] = 0] = "CSV";
+    DataFormat[DataFormat["XML"] = 1] = "XML";
+    DataFormat[DataFormat["JSON"] = 2] = "JSON";
+    DataFormat[DataFormat["MESSAGE_PACK"] = 3] = "MESSAGE_PACK";
+})(DataFormat || (DataFormat = {}));
+/**
+ * Supported data types
+ * @beta
+ */
+var DataType;
+(function (DataType) {
+    DataType["RECORD"] = "record";
+    DataType["NULL"] = "null";
+    DataType["BOOLEAN"] = "boolean";
+    DataType["INT"] = "int";
+    DataType["LONG"] = "long";
+    DataType["FLOAT"] = "float";
+    DataType["DOUBLE"] = "double";
+    DataType["BYTES"] = "bytes";
+    DataType["STRING"] = "string";
+    DataType["ENUM"] = "enum";
+    DataType["MAP"] = "map";
+    DataType["FIXED_STRING"] = "fixed";
+    DataType["ARRAY"] = "array";
+})(DataType || (DataType = {}));
+
+export { DataFormat, DataType };

package/data/model.cjs

@@ -0,0 +1,43 @@
+'use strict';
+
+var model = require('./model/model.cjs');
+var property = require('./model/property.cjs');
+var types = require('./model/types.cjs');
+var credentials = require('./model/credentials.cjs');
+var plugin = require('./model/plugin.cjs');
+var extra = require('./model/extra.cjs');
+
+
+
+exports.Model = model.Model;
+exports.Optional = model.Optional;
+exports.Alias = property.Alias;
+exports.ArrayField = property.ArrayField;
+exports.Field = property.Field;
+exports.Ignore = property.Ignore;
+exports.LowerBound = property.LowerBound;
+exports.MapField = property.MapField;
+exports.RaiseError = property.RaiseError;
+exports.Range = property.Range;
+exports.Readonly = property.Readonly;
+exports.SchemaType = property.SchemaType;
+exports.UpperBound = property.UpperBound;
+exports.Validator = property.Validator;
+Object.defineProperty(exports, 'DataFormat', {
+	enumerable: true,
+	get: function () { return types.DataFormat; }
+});
+Object.defineProperty(exports, 'DataType', {
+	enumerable: true,
+	get: function () { return types.DataType; }
+});
+exports.APIKeyCredentials = credentials.APIKeyCredentials;
+exports.BasicCredentials = credentials.BasicCredentials;
+exports.BearerCredentials = credentials.BearerCredentials;
+exports.Credentials = credentials.Credentials;
+exports.createModelClassAnnotationTag = plugin.createModelClassAnnotationTag;
+exports.createModelFieldAnnotationTag = plugin.createModelFieldAnnotationTag;
+exports.getModelClassAnnotationTagProperties = plugin.getModelClassAnnotationTagProperties;
+exports.getModelFieldAnnotationTagProperties = plugin.getModelFieldAnnotationTagProperties;
+exports.Union = extra.Union;
+exports.View = extra.View;

package/data/model.mjs

@@ -0,0 +1,6 @@
+export { Model, Optional } from './model/model.mjs';
+export { Alias, ArrayField, Field, Ignore, LowerBound, MapField, RaiseError, Range, Readonly, SchemaType, UpperBound, Validator } from './model/property.mjs';
+export { DataFormat, DataType } from './model/types.mjs';
+export { APIKeyCredentials, BasicCredentials, BearerCredentials, Credentials } from './model/credentials.mjs';
+export { createModelClassAnnotationTag, createModelFieldAnnotationTag, getModelClassAnnotationTagProperties, getModelFieldAnnotationTagProperties } from './model/plugin.mjs';
+export { Union, View } from './model/extra.mjs';

package/data/signal.cjs

@@ -0,0 +1,47 @@
+'use strict';
+
+var stream = require('../stream.cjs');
+require('../data-structures/object/WatchableObject.cjs');
+require('object-hash');
+require('ramda');
+require('../_virtual/_tslib.cjs');
+require('uuid');
+var Queue = require('../data-structures/object/Queue.cjs');
+
+class Signal {
+    constructor(source) {
+        this.subscribers = new Set();
+        this.source = source instanceof stream.Stream ? source : source.streamEntries;
+    }
+    start() {
+        this.task = this.source.forEach((value) => {
+            for (const subscriber of this.subscribers) {
+                subscriber(value);
+            }
+        });
+    }
+    stop() {
+        var _a;
+        (_a = this.task) === null || _a === void 0 ? void 0 : _a.cancel();
+    }
+    subscribe(callback) {
+        this.subscribers.add(callback);
+        if (this.latestValue !== undefined) {
+            callback(this.latestValue);
+        }
+        return {
+            cancel: () => {
+                this.subscribers.delete(callback);
+            },
+        };
+    }
+    stream(objectMaxSize, expiryPeriod) {
+        const queue = new Queue.Queue(objectMaxSize, expiryPeriod);
+        const token = this.subscribe((value) => {
+            queue.enqueue(value);
+        });
+        return queue.streamEntries.onCancellation(token.cancel);
+    }
+}
+
+exports.Signal = Signal;

package/data/signal.d.ts

@@ -0,0 +1,17 @@
+import { Stream } from "../stream";
+import { WaitPeriod } from "../future";
+import { Queue } from "../data-structures/object";
+export interface Token {
+    cancel: () => void;
+}
+export declare class Signal<T> {
+    private readonly subscribers;
+    private readonly latestValue;
+    private task?;
+    private readonly source;
+    constructor(source: Stream<T> | Queue<T>);
+    start(): void;
+    stop(): void;
+    subscribe(callback: (value: T) => void): Token;
+    stream(objectMaxSize?: number, expiryPeriod?: WaitPeriod): Stream<T>;
+}

package/data/signal.mjs

@@ -0,0 +1,45 @@
+import { Stream } from '../stream.mjs';
+import '../data-structures/object/WatchableObject.mjs';
+import 'object-hash';
+import 'ramda';
+import '../_virtual/_tslib.mjs';
+import 'uuid';
+import { Queue } from '../data-structures/object/Queue.mjs';
+
+class Signal {
+    constructor(source) {
+        this.subscribers = new Set();
+        this.source = source instanceof Stream ? source : source.streamEntries;
+    }
+    start() {
+        this.task = this.source.forEach((value) => {
+            for (const subscriber of this.subscribers) {
+                subscriber(value);
+            }
+        });
+    }
+    stop() {
+        var _a;
+        (_a = this.task) === null || _a === void 0 ? void 0 : _a.cancel();
+    }
+    subscribe(callback) {
+        this.subscribers.add(callback);
+        if (this.latestValue !== undefined) {
+            callback(this.latestValue);
+        }
+        return {
+            cancel: () => {
+                this.subscribers.delete(callback);
+            },
+        };
+    }
+    stream(objectMaxSize, expiryPeriod) {
+        const queue = new Queue(objectMaxSize, expiryPeriod);
+        const token = this.subscribe((value) => {
+            queue.enqueue(value);
+        });
+        return queue.streamEntries.onCancellation(token.cancel);
+    }
+}
+
+export { Signal };

package/data/store/index.d.ts

@@ -0,0 +1,4 @@
+export { CacheManager, PersistenceStore } from "./manager";
+export type { Cache } from "./manager";
+export { LocalWebStore, SessionWebStore } from "./web";
+export { JSONFileStore } from "./json";

package/data/store/json.cjs

@@ -0,0 +1,58 @@
+'use strict';
+
+var files = require('../../files.cjs');
+var future = require('../../future/future.cjs');
+require('ramda');
+require('../../stream.cjs');
+
+class JSONFileStore {
+    constructor(filename) {
+        this.filename = filename;
+    }
+    close() {
+        return future.Future.completed(null);
+    }
+    open() {
+        return future.Future.completed(null);
+    }
+    clear() {
+        return files.Files.remove(this.filename);
+    }
+    get(key) {
+        return this.loadJSONData().thenApply(({ value }) => value[key]);
+    }
+    keys() {
+        return this.loadJSONData()
+            .thenApply(({ value }) => Object.keys(value))
+            .stream.flatten();
+    }
+    length() {
+        return this.loadJSONData().thenApply(({ value }) => Object.keys(value).length);
+    }
+    remove(key) {
+        return this.loadJSONData().thenApply(({ value }) => {
+            // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+            delete value[key];
+            return this.saveJSONData(value);
+        });
+    }
+    set(key, value) {
+        return this.loadJSONData().thenApply(({ value: data }) => {
+            data[key] = value;
+            return this.saveJSONData(data);
+        });
+    }
+    values() {
+        return this.loadJSONData()
+            .thenApply(({ value }) => Object.values(value))
+            .stream.flatten();
+    }
+    loadJSONData() {
+        return files.Files.readString(this.filename).thenApply(({ value }) => (value ? JSON.parse(value) : {}));
+    }
+    saveJSONData(data) {
+        return files.Files.write(JSON.stringify(data), this.filename);
+    }
+}
+
+exports.JSONFileStore = JSONFileStore;

package/data/store/json.d.ts

@@ -0,0 +1,18 @@
+import { PersistenceStore } from "./manager";
+import { Future } from "../../future";
+import { Stream } from "../../stream";
+export declare class JSONFileStore implements PersistenceStore {
+    private readonly filename;
+    constructor(filename: string);
+    close(): Future<void>;
+    open(): Future<void>;
+    clear(): Future<void>;
+    get(key: string): Future<string | undefined>;
+    keys(): Stream<string>;
+    length(): Future<number>;
+    remove(key: string): Future<void>;
+    set(key: string, value: string): Future<void>;
+    values(): Stream<string>;
+    private loadJSONData;
+    private saveJSONData;
+}

package/data/store/json.mjs

@@ -0,0 +1,56 @@
+import { Files } from '../../files.mjs';
+import { Future } from '../../future/future.mjs';
+import 'ramda';
+import '../../stream.mjs';
+
+class JSONFileStore {
+    constructor(filename) {
+        this.filename = filename;
+    }
+    close() {
+        return Future.completed(null);
+    }
+    open() {
+        return Future.completed(null);
+    }
+    clear() {
+        return Files.remove(this.filename);
+    }
+    get(key) {
+        return this.loadJSONData().thenApply(({ value }) => value[key]);
+    }
+    keys() {
+        return this.loadJSONData()
+            .thenApply(({ value }) => Object.keys(value))
+            .stream.flatten();
+    }
+    length() {
+        return this.loadJSONData().thenApply(({ value }) => Object.keys(value).length);
+    }
+    remove(key) {
+        return this.loadJSONData().thenApply(({ value }) => {
+            // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+            delete value[key];
+            return this.saveJSONData(value);
+        });
+    }
+    set(key, value) {
+        return this.loadJSONData().thenApply(({ value: data }) => {
+            data[key] = value;
+            return this.saveJSONData(data);
+        });
+    }
+    values() {
+        return this.loadJSONData()
+            .thenApply(({ value }) => Object.values(value))
+            .stream.flatten();
+    }
+    loadJSONData() {
+        return Files.readString(this.filename).thenApply(({ value }) => (value ? JSON.parse(value) : {}));
+    }
+    saveJSONData(data) {
+        return Files.write(JSON.stringify(data), this.filename);
+    }
+}
+
+export { JSONFileStore };