@opra/common 0.25.5 → 0.26.1

package/cjs/document/resource/operation-decorator.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOperationDecorator = void 0;
+const constants_js_1 = require("../constants.js");
+function createOperationDecorator(operation, options, list) {
+    const decorator = ((target, propertyKey) => {
+        if (propertyKey !== operation)
+            throw new TypeError(`Name of the handler name should be '${operation}'`);
+        const resourceMetadata = (Reflect.getOwnMetadata(constants_js_1.RESOURCE_METADATA, target.constructor) || {});
+        resourceMetadata.operations = resourceMetadata.operations || {};
+        const operationMeta = { ...options };
+        resourceMetadata.operations[operation] = operationMeta;
+        for (const fn of list)
+            fn(operationMeta, target, propertyKey);
+        Reflect.defineMetadata(constants_js_1.RESOURCE_METADATA, resourceMetadata, target.constructor);
+    });
+    decorator.Parameter = (name, arg0) => {
+        const parameterOptions = typeof arg0 === 'string' || typeof arg0 === 'function' ? { type: arg0 } : { ...arg0 };
+        list.push((operationMeta) => {
+            operationMeta.parameters = operationMeta.parameters || {};
+            operationMeta.parameters[name] = { ...parameterOptions };
+        });
+        return decorator;
+    };
+    return decorator;
+}
+exports.createOperationDecorator = createOperationDecorator;

package/cjs/document/resource/parameter.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parameter = void 0;
+const tslib_1 = require("tslib");
+const vg = tslib_1.__importStar(require("valgen"));
+const index_js_1 = require("../../helpers/index.js");
+/**
+ *
+ * @class Parameter
+ */
+class Parameter {
+    constructor(name, init) {
+        this.name = name;
+        this.type = init.type;
+        this.description = init.description;
+        this.isArray = init.isArray;
+        this.default = init.default;
+        this.required = init.required;
+        this.deprecated = init.deprecated;
+        this.examples = init.examples;
+        this.isBuiltin = init.isBuiltin;
+    }
+    exportSchema(options) {
+        return (0, index_js_1.omitUndefined)({
+            type: this.type.name ? this.type.name : this.type.exportSchema(options),
+            description: this.description,
+            isArray: this.isArray,
+            default: this.default,
+            required: this.required,
+            deprecated: this.deprecated,
+            examples: this.examples
+        });
+    }
+    getDecoder() {
+        if (!this._decoder)
+            this._decoder = this.generateCodec('decode');
+        return this._decoder;
+    }
+    getEncoder() {
+        if (!this._encoder)
+            this._encoder = this.generateCodec('encode');
+        return this._encoder;
+    }
+    generateCodec(codec, options) {
+        let fn = this.type.generateCodec(codec, options);
+        if (this.isArray)
+            fn = vg.stringSplit(',');
+        return !options?.partial && this.required ? vg.required(fn) : vg.optional(fn);
+    }
+}
+exports.Parameter = Parameter;

package/cjs/document/{decorators/resource.decorator.js → resource/resource-decorator.js}

@@ -5,10 +5,16 @@ const tslib_1 = require("tslib");
 const lodash_omit_1 = tslib_1.__importDefault(require("lodash.omit"));
 const putil_merge_1 = tslib_1.__importDefault(require("putil-merge"));
 const constants_js_1 = require("../constants.js");
-function ResourceDecorator(kind, options) {
+function ResourceDecorator(kind, meta) {
     const namePattern = new RegExp(`^(.*)(${kind}|Resource|Controller)$`);
     return function (target) {
-        const name = options?.name || namePattern.exec(target.name)?.[1] || target.name;
+        let name = meta?.name;
+        if (!name) {
+            name = namePattern.exec(target.name)?.[1] || target.name;
+            // Containers may start with lowercase
+            if (kind === 'Container')
+                name = name.charAt(0).toLowerCase() + name.substring(1);
+        }
         const metadata = { kind, name };
         const baseMetadata = Reflect.getOwnMetadata(constants_js_1.RESOURCE_METADATA, Object.getPrototypeOf(target));
         if (baseMetadata)
@@ -19,20 +25,9 @@ function ResourceDecorator(kind, options) {
         (0, putil_merge_1.default)(metadata, {
             kind,
             name,
-            ...(0, lodash_omit_1.default)(options, ['kind', 'name', 'controller'])
+            ...(0, lodash_omit_1.default)(meta, ['kind', 'name', 'controller'])
         }, { deep: true });
         Reflect.defineMetadata(constants_js_1.RESOURCE_METADATA, metadata, target);
     };
 }
 exports.ResourceDecorator = ResourceDecorator;
-ResourceDecorator.Action = function (options) {
-    return (target, propertyKey) => {
-        if (typeof propertyKey !== 'string')
-            throw new TypeError(`This decorator can't be used for Symbol keys'`);
-        const actionMeta = { ...options };
-        const resourceMetadata = (Reflect.getOwnMetadata(constants_js_1.RESOURCE_METADATA, target.constructor) || {});
-        resourceMetadata.actions = resourceMetadata.actions || {};
-        resourceMetadata.actions[propertyKey] = actionMeta;
-        Reflect.defineMetadata(constants_js_1.RESOURCE_METADATA, resourceMetadata, target.constructor);
-    };
-};

package/cjs/document/resource/resource.js

@@ -6,19 +6,34 @@ const object_utils_js_1 = require("../../helpers/object-utils.js");
 const inspect_util_js_1 = require("../utils/inspect.util.js");
 const endpoint_js_1 = require("./endpoint.js");
 class Resource {
-    constructor(document, init) {
+    constructor(parent, init) {
         this.actions = new index_js_1.ResponsiveMap();
-        this.document = document;
+        if (parent instanceof Resource) {
+            this.document = parent.document;
+            this.parent = parent;
+        }
+        else
+            this.document = parent;
         this.name = init.name;
         this.description = init.description;
         this.controller = init.controller;
+        if (this.controller) {
+            this.ctor = Object.getPrototypeOf(this.controller).constructor;
+        }
+        else
+            this.ctor = init.ctor;
         if (init.actions) {
             for (const [name, meta] of Object.entries(init.actions)) {
-                this.actions.set(name, new endpoint_js_1.Endpoint({ ...meta, name }));
+                this.actions.set(name, new endpoint_js_1.Endpoint(this, name, meta));
             }
         }
     }
-    exportSchema() {
+    getFullPath() {
+        if (this.parent && this.parent.name)
+            return this.parent?.getFullPath() + '/' + this.name;
+        return this.name;
+    }
+    exportSchema(options) {
         const schema = (0, object_utils_js_1.omitUndefined)({
             kind: this.kind,
             description: this.description,
@@ -26,7 +41,7 @@ class Resource {
         if (this.actions.size) {
             schema.actions = {};
             for (const action of this.actions.values()) {
-                schema.actions[action.name] = action.exportSchema();
+                schema.actions[action.name] = action.exportSchema(options);
             }
         }
         return schema;

package/cjs/document/resource/singleton-class.js

@@ -1,53 +1,73 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SingletonClass = void 0;
-const index_js_1 = require("../../helpers/index.js");
-const index_js_2 = require("../../schema/index.js");
-const generate_codec_js_1 = require("../utils/generate-codec.js");
-const resource_js_1 = require("./resource.js");
-class SingletonClass extends resource_js_1.Resource {
-    constructor(document, init) {
-        super(document, init);
-        this._decoders = {};
-        this._encoders = {};
-        this.kind = index_js_2.OpraSchema.Singleton.Kind;
-        this.controller = init.controller;
-        this.operations = { ...init.operations };
+const index_js_1 = require("../../schema/index.js");
+const crud_resource_js_1 = require("./crud-resource.js");
+class SingletonClass extends crud_resource_js_1.CrudResource {
+    constructor(parent, init) {
+        super(parent, init);
+        this.kind = index_js_1.OpraSchema.Singleton.Kind;
         this.type = init.type;
+        // ------------------
+        let endpoint = this.operations.get('create');
+        if (endpoint) {
+            endpoint.returnType = this.type;
+            endpoint.decode = this.type.generateCodec('decode', {
+                partial: true,
+                pick: endpoint.inputPickFields,
+                omit: endpoint.inputOmitFields,
+            });
+            endpoint.encode = this.type.generateCodec('encode', {
+                partial: true,
+                pick: endpoint.outputPickFields,
+                omit: endpoint.outputOmitFields,
+            });
+            endpoint.defineParameter('pick', { type: 'string', isArray: true, isBuiltin: true });
+            endpoint.defineParameter('omit', { type: 'string', isArray: true, isBuiltin: true });
+            endpoint.defineParameter('include', { type: 'string', isArray: true, isBuiltin: true });
+        }
+        // ------------------
+        endpoint = this.operations.get('get');
+        if (endpoint) {
+            endpoint.returnType = this.type;
+            endpoint.encode = this.type.generateCodec('encode', {
+                partial: true,
+                pick: endpoint.outputPickFields,
+                omit: endpoint.outputOmitFields,
+            });
+            endpoint.defineParameter('pick', { type: 'string', isArray: true, isBuiltin: true });
+            endpoint.defineParameter('omit', { type: 'string', isArray: true, isBuiltin: true });
+            endpoint.defineParameter('include', { type: 'string', isArray: true, isBuiltin: true });
+        }
+        // ------------------
+        endpoint = this.operations.get('update');
+        if (endpoint) {
+            endpoint.returnType = this.type;
+            endpoint.decode = this.type.generateCodec('decode', {
+                pick: endpoint.inputPickFields,
+                omit: endpoint.inputOmitFields,
+            });
+            endpoint.encode = this.type.generateCodec('encode', {
+                partial: true,
+                pick: endpoint.outputPickFields,
+                omit: endpoint.outputOmitFields,
+            });
+            endpoint.defineParameter('pick', { type: 'string', isArray: true, isBuiltin: true });
+            endpoint.defineParameter('omit', { type: 'string', isArray: true, isBuiltin: true });
+            endpoint.defineParameter('include', { type: 'string', isArray: true, isBuiltin: true });
+        }
     }
-    exportSchema() {
+    getOperation(name) {
+        return super.getOperation(name);
+    }
+    exportSchema(options) {
         return {
-            ...super.exportSchema(),
-            ...(0, index_js_1.omitUndefined)({
-                type: this.type.name || 'any',
-                operations: this.operations
-            })
+            ...super.exportSchema(options),
+            type: this.type.name || 'any'
         };
     }
     normalizeFieldPath(path) {
         return this.type.normalizeFieldPath(path);
     }
-    getDecoder(endpoint) {
-        let decoder = this._decoders[endpoint];
-        if (decoder)
-            return decoder;
-        const options = {
-            partial: endpoint !== 'create'
-        };
-        decoder = (0, generate_codec_js_1.generateCodec)(this.type, 'decode', options);
-        this._decoders[endpoint] = decoder;
-        return decoder;
-    }
-    getEncoder(endpoint) {
-        let encoder = this._encoders[endpoint];
-        if (encoder)
-            return encoder;
-        const options = {
-            partial: true
-        };
-        encoder = (0, generate_codec_js_1.generateCodec)(this.type, 'encode', options);
-        this._encoders[endpoint] = encoder;
-        return encoder;
-    }
 }
 exports.SingletonClass = SingletonClass;

package/cjs/document/resource/singleton-decorator.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SingletonDecorator = void 0;
+const index_js_1 = require("../../schema/index.js");
+const action_decorator_js_1 = require("./action-decorator.js");
+const collection_decorator_js_1 = require("./collection-decorator.js");
+const resource_decorator_js_1 = require("./resource-decorator.js");
+const operationProperties = ['create', 'delete', 'get', 'update'];
+function SingletonDecorator(type, options) {
+    return (0, resource_decorator_js_1.ResourceDecorator)(index_js_1.OpraSchema.Singleton.Kind, { ...options, type });
+}
+exports.SingletonDecorator = SingletonDecorator;
+Object.assign(SingletonDecorator, resource_decorator_js_1.ResourceDecorator);
+/*
+ * Action PropertyDecorator
+ */
+(function (SingletonDecorator) {
+    /**
+     * Action PropertyDecorator
+     */
+    function Action(options) {
+        const list = [];
+        return (0, action_decorator_js_1.createActionDecorator)(options, operationProperties, list);
+    }
+    SingletonDecorator.Action = Action;
+    function Create(options) {
+        return collection_decorator_js_1.CollectionDecorator.Create(options);
+    }
+    SingletonDecorator.Create = Create;
+})(SingletonDecorator || (exports.SingletonDecorator = SingletonDecorator = {}));
+/*
+ * Get PropertyDecorator
+ */
+(function (SingletonDecorator) {
+    function Get(options) {
+        return collection_decorator_js_1.CollectionDecorator.Get(options);
+    }
+    SingletonDecorator.Get = Get;
+})(SingletonDecorator || (exports.SingletonDecorator = SingletonDecorator = {}));
+/*
+ * Delete PropertyDecorator
+ */
+(function (SingletonDecorator) {
+    function Delete(options) {
+        return collection_decorator_js_1.CollectionDecorator.Delete(options);
+    }
+    SingletonDecorator.Delete = Delete;
+})(SingletonDecorator || (exports.SingletonDecorator = SingletonDecorator = {}));
+/*
+ * Update PropertyDecorator
+ */
+(function (SingletonDecorator) {
+    function Update(options) {
+        return collection_decorator_js_1.CollectionDecorator.Update(options);
+    }
+    SingletonDecorator.Update = Update;
+})(SingletonDecorator || (exports.SingletonDecorator = SingletonDecorator = {}));

package/cjs/document/resource/singleton.js

@@ -4,21 +4,21 @@ exports.Singleton = void 0;
 const tslib_1 = require("tslib");
 const putil_merge_1 = tslib_1.__importDefault(require("putil-merge"));
 const constants_js_1 = require("../constants.js");
-const singleton_decorator_js_1 = require("../decorators/singleton.decorator.js");
 const singleton_class_js_1 = require("./singleton-class.js");
+const singleton_decorator_js_1 = require("./singleton-decorator.js");
 /**
  * @class Singleton
  * @decorator Singleton
  */
 exports.Singleton = function (...args) {
-    // ClassDecorator
+    // Decorator
     if (!this) {
         const [type, options] = args;
         return exports.Singleton[constants_js_1.DECORATOR].call(undefined, type, options);
     }
     // Constructor
-    const [document, init] = args;
-    (0, putil_merge_1.default)(this, new singleton_class_js_1.SingletonClass(document, init), { descriptor: true });
+    const [parent, init] = args;
+    (0, putil_merge_1.default)(this, new singleton_class_js_1.SingletonClass(parent, init), { descriptor: true });
 };
 exports.Singleton.prototype = singleton_class_js_1.SingletonClass.prototype;
 Object.assign(exports.Singleton, singleton_decorator_js_1.SingletonDecorator);

package/cjs/document/resource/storage-class.js

@@ -1,24 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StorageClass = void 0;
-const index_js_1 = require("../../helpers/index.js");
-const index_js_2 = require("../../schema/index.js");
-const resource_js_1 = require("./resource.js");
-class StorageClass extends resource_js_1.Resource {
-    constructor(document, init) {
-        super(document, init);
-        this.kind = index_js_2.OpraSchema.Storage.Kind;
-        this.controller = init.controller;
-        this.operations = { ...init.operations };
+const index_js_1 = require("../../schema/index.js");
+const crud_resource_js_1 = require("./crud-resource.js");
+class StorageClass extends crud_resource_js_1.CrudResource {
+    constructor(parent, init) {
+        super(parent, init);
+        this.kind = index_js_1.OpraSchema.Storage.Kind;
     }
-    exportSchema() {
-        return {
-            ...super.exportSchema(),
-            ...(0, index_js_1.omitUndefined)({
-                kind: index_js_2.OpraSchema.Storage.Kind,
-                operations: this.operations
-            })
-        };
+    getOperation(name) {
+        return super.getOperation(name);
+    }
+    exportSchema(options) {
+        return super.exportSchema(options);
     }
 }
 exports.StorageClass = StorageClass;

package/cjs/document/resource/storage-decorator.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageDecorator = void 0;
+const index_js_1 = require("../../schema/index.js");
+const action_decorator_js_1 = require("./action-decorator.js");
+const operation_decorator_js_1 = require("./operation-decorator.js");
+const resource_decorator_js_1 = require("./resource-decorator.js");
+const operationProperties = ['delete', 'get', 'post'];
+function StorageDecorator(options) {
+    return (0, resource_decorator_js_1.ResourceDecorator)(index_js_1.OpraSchema.Storage.Kind, options);
+}
+exports.StorageDecorator = StorageDecorator;
+Object.assign(StorageDecorator, resource_decorator_js_1.ResourceDecorator);
+/*
+ * Action PropertyDecorator
+ */
+(function (StorageDecorator) {
+    /**
+     * Action PropertyDecorator
+     */
+    function Action(options) {
+        const list = [];
+        return (0, action_decorator_js_1.createActionDecorator)(options, operationProperties, list);
+    }
+    StorageDecorator.Action = Action;
+    function Delete(options) {
+        const list = [];
+        return (0, operation_decorator_js_1.createOperationDecorator)('delete', options, list);
+    }
+    StorageDecorator.Delete = Delete;
+    function Get(options) {
+        const list = [];
+        return (0, operation_decorator_js_1.createOperationDecorator)('get', options, list);
+    }
+    StorageDecorator.Get = Get;
+    function Post(options) {
+        const list = [];
+        const decorator = (0, operation_decorator_js_1.createOperationDecorator)('post', options, list);
+        decorator.MaxFields = (amount) => {
+            list.push(operationMeta => operationMeta.maxFields = amount);
+            return decorator;
+        };
+        decorator.MaxFieldSize = (amount) => {
+            list.push(operationMeta => operationMeta.maxFieldsSize = amount);
+            return decorator;
+        };
+        decorator.MaxFiles = (amount) => {
+            list.push(operationMeta => operationMeta.maxFiles = amount);
+            return decorator;
+        };
+        decorator.MaxFileSize = (sizeInBytes) => {
+            list.push(operationMeta => operationMeta.maxFileSize = sizeInBytes);
+            return decorator;
+        };
+        decorator.MaxTotalFileSize = (sizeInBytes) => {
+            list.push(operationMeta => operationMeta.maxTotalFileSize = sizeInBytes);
+            return decorator;
+        };
+        decorator.MinFileSize = (sizeInBytes) => {
+            list.push(operationMeta => operationMeta.minFileSize = sizeInBytes);
+            return decorator;
+        };
+        return decorator;
+    }
+    StorageDecorator.Post = Post;
+})(StorageDecorator || (exports.StorageDecorator = StorageDecorator = {}));

package/cjs/document/resource/storage.js

@@ -4,8 +4,8 @@ exports.Storage = void 0;
 const tslib_1 = require("tslib");
 const putil_merge_1 = tslib_1.__importDefault(require("putil-merge"));
 const constants_js_1 = require("../constants.js");
-const storage_decorator_js_1 = require("../decorators/storage.decorator.js");
 const storage_class_js_1 = require("./storage-class.js");
+const storage_decorator_js_1 = require("./storage-decorator.js");
 /**
  * @class Storage
  * @decorator Storage
@@ -17,8 +17,8 @@ exports.Storage = function (...args) {
         return exports.Storage[constants_js_1.DECORATOR].call(undefined, options);
     }
     // Constructor
-    const [document, init] = args;
-    (0, putil_merge_1.default)(this, new storage_class_js_1.StorageClass(document, init), { descriptor: true });
+    const [parent, init] = args;
+    (0, putil_merge_1.default)(this, new storage_class_js_1.StorageClass(parent, init), { descriptor: true });
 };
 exports.Storage.prototype = storage_class_js_1.StorageClass.prototype;
 Object.assign(exports.Storage, storage_decorator_js_1.StorageDecorator);