gingersnap 0.22.0

package/data/model/plugin.mjs

@@ -0,0 +1,72 @@
+import * as R from 'ramda';
+import { namespacedModelInternalProps, Model } from './model.mjs';
+
+const modelClassTags = {};
+/**
+ * Creates a custom class tag
+ * @param name Name of the tag
+ * @param properties any properties that should be saved
+ */
+const createModelClassAnnotationTag = (name, properties = {}) => (constructor) => {
+    modelClassTags[name] = {
+        properties,
+        modelClass: constructor.prototype,
+        modelClassName: constructor.name,
+    };
+};
+/**
+ * Retrieves a list of properties set by one or more custom class tags
+ * @param tagNames Array<string>
+ * @param ModelClass Class<Model>
+ */
+const getModelClassAnnotationTagProperties = (tagNames, ModelClass) => {
+    return R.map((tag) => modelClassTags[tag], tagNames).filter((v) => v);
+};
+/**
+ * Creates a custom field tag
+ * @param name Name of the tag
+ * @param properties any properties that should be saved
+ * @param onFieldCreated callback executed once property exist on a model (Optional)
+ */
+const createModelFieldAnnotationTag = (name, properties = {}, onFieldCreated) => (target, key) => {
+    var _a, _b;
+    const props = (_a = namespacedModelInternalProps.get(target.constructor.name)) !== null && _a !== void 0 ? _a : {
+        fields: new Map(),
+    };
+    const result = R.find(([k, v]) => v.name === key, Array.from(props.fields.entries()));
+    if (!result) {
+        throw new Error(`Cannot create annotation tag of type ${name}, field does not exist as yet`);
+    }
+    props.fields.get(result[0]).customTags = (_b = props.fields.get(result[0]).customTags) !== null && _b !== void 0 ? _b : {};
+    props.fields.get(result[0]).customTags[name] = {
+        __callback__: onFieldCreated,
+        properties,
+    };
+    props.parent = Object.getPrototypeOf(target).constructor.name;
+    namespacedModelInternalProps.set(target.constructor.name, props);
+};
+/**
+ *  Retrieves a list of properties set by one or more custom field tags
+ * @param tagNames Array<String>
+ * @param ModelClass Class<Model>
+ */
+const getModelFieldAnnotationTagProperties = (tagNames, ModelClass) => {
+    const props = Model.buildPropTree(ModelClass);
+    return R.map(([k, v]) => {
+        if (v.customTags) {
+            const tagName = tagNames.find((t) => t in v.customTags);
+            return tagName
+                ? {
+                    tagName,
+                    fieldName: v.name,
+                    Type: v.Type,
+                    isArray: v.isArray,
+                    tagProperties: v.customTags[tagName].properties,
+                }
+                : null;
+        }
+        return null;
+    }, Array.from(props.fields.entries())).filter((v) => v);
+};
+
+export { createModelClassAnnotationTag, createModelFieldAnnotationTag, getModelClassAnnotationTagProperties, getModelFieldAnnotationTagProperties };

package/data/model/property.cjs

@@ -0,0 +1,310 @@
+'use strict';
+
+var R = require('ramda');
+var model = require('./model.cjs');
+var InvalidType = require('../../errors/InvalidType.cjs');
+var InvalidValue = require('../../errors/InvalidValue.cjs');
+var types = require('./types.cjs');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var R__namespace = /*#__PURE__*/_interopNamespaceDefault(R);
+
+/**
+ * Creates a decorator that updates a field
+ * @param functor updater function
+ * @returns a decorator
+ */
+const createFieldUpdater = (functor) => (target, key) => {
+    var _a;
+    const props = (_a = model.namespacedModelInternalProps.get(target.constructor.name)) !== null && _a !== void 0 ? _a : {
+        fields: new Map(),
+    };
+    const field = R__namespace.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;
+    model.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 model.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 = model.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 === model.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.InvalidType(`Type mismatch for property ${key}`);
+    }
+    if (type instanceof Number) {
+        schema.dataType = types.DataType.DOUBLE;
+    }
+    else if (type instanceof String) {
+        schema.dataType = types.DataType.STRING;
+    }
+    else if (type instanceof Boolean) {
+        schema.dataType = types.DataType.BOOLEAN;
+    }
+    else if (type instanceof model.Model) {
+        schema.dataType = types.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;
+    model.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 = model.namespacedModelInternalProps.get(target.constructor.name)) !== null && _a !== void 0 ? _a : {
+        fields: new Map(),
+    };
+    const schema = { dataType: types.DataType.ARRAY };
+    const dtype = Reflect.getMetadata("design:type", target, key);
+    const optional = dtype === model.Optional;
+    schema.options = { useOptionalObj: optional, optional };
+    if (type instanceof Number) {
+        schema.itemType = types.DataType.DOUBLE;
+    }
+    else if (type instanceof String) {
+        schema.itemType = types.DataType.STRING;
+    }
+    else if (type instanceof Boolean) {
+        schema.itemType = types.DataType.BOOLEAN;
+    }
+    else if (type instanceof model.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;
+    model.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 = model.namespacedModelInternalProps.get(target.constructor.name)) !== null && _a !== void 0 ? _a : {
+        fields: new Map(),
+    };
+    const schema = { dataType: types.DataType.MAP };
+    const dtype = Reflect.getMetadata("design:type", target, key);
+    const optional = dtype === model.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;
+    model.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 = model.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;
+    model.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.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.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.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.InvalidValue(`value is not within the range of ${lower} <= v ` + (inclusive ? `<= ${upper}` : `< ${upper}`)));
+
+exports.Alias = Alias;
+exports.ArrayField = ArrayField;
+exports.Field = Field;
+exports.Ignore = Ignore;
+exports.LowerBound = LowerBound;
+exports.MapField = MapField;
+exports.RaiseError = RaiseError;
+exports.Range = Range;
+exports.Readonly = Readonly;
+exports.SchemaType = SchemaType;
+exports.UpperBound = UpperBound;
+exports.Validator = Validator;

package/data/model/property.d.ts

@@ -0,0 +1,83 @@
+import { IgnoreProps } from "./model";
+import { DataType } from "./types";
+/**
+ * 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
+ */
+export declare const Field: (name?: string, type?: any) => (target: any, key: string) => void;
+/**
+ * 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
+ */
+export declare const ArrayField: (type: any, name?: string) => (target: any, key: string) => void;
+/**
+ * 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
+ */
+export declare const MapField: (keyType: any, valueType: any, name?: string) => (target: any, key: string) => void;
+/**
+ * Alternative name for the associated field
+ * @param name
+ */
+export declare const Alias: (name: string) => (target: any, key: string) => void;
+/**
+ * Makes the given property only readable
+ * @constructor
+ */
+export declare const Readonly: (target: any, key: string) => void;
+/**
+ * Validates the value assigned to the associated property
+ * @param matcher functor to check if the assigned value is valid
+ */
+export declare const Validator: (matcher: string | number | boolean | RegExp | ((v: any) => boolean)) => (target: any, key: string) => void;
+/**
+ * Raises an error if the field contains an error
+ * @constructor
+ */
+export declare const RaiseError: (target: any, key: string) => void;
+/**
+ * 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
+ */
+export declare const Ignore: (value?: IgnoreProps) => (target: any, key: string) => void;
+/**
+ * Registers a schema type for the given field
+ * @param dataType
+ * @param options
+ */
+export declare const SchemaType: (dataType: DataType, options?: {
+    values?: string[];
+    length?: number;
+    itemType?: string;
+    recordClass?: any;
+    optional?: boolean;
+}) => (target: any, key: string) => void;
+/**
+ * Decorator that applies a lower limit validation on a numeric field
+ * @param value limit
+ * @param inclusive should the limit be included. Default is false
+ */
+export declare const LowerBound: (value: number, inclusive?: boolean) => (target: any, key: string) => void;
+/**
+ * Decorator that applies an upper limit validation on a numeric field
+ * @param value limit
+ * @param inclusive should the limit be included. Default is false
+ */
+export declare const UpperBound: (value: number, inclusive?: boolean) => (target: any, key: string) => void;
+/**
+ * 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
+ */
+export declare const Range: (lower: number, upper: number, inclusive?: boolean) => (target: any, key: string) => void;