@merkaly/api 0.2.4-7 → 0.2.4-9

package/.output/abstract/abstract.entity.d.ts

@@ -1,4 +1,4 @@
-import { Document } from 'mongoose';
+
 export declare abstract class AbstractEntity {
     static $index: string;
     readonly _id: string;

package/.output/abstract/abstract.exception.d.ts

@@ -0,0 +1,11 @@
+import { ArgumentsHost, ExceptionFilter, HttpException } from '@nestjs/common';
+import { Request, Response } from 'express';
+import { LoggerService } from '../services/logger.service';
+export declare abstract class AbstractException implements ExceptionFilter {
+    protected readonly $logger: LoggerService;
+    protected request: Request;
+    protected response: Response;
+    protected host: ArgumentsHost;
+    catch(exception: HttpException, host: ArgumentsHost): Response<any, Record<string, any>>;
+    protected abstract handleError(exception: HttpException): HttpException;
+}

package/.output/abstract/abstract.exception.js

@@ -0,0 +1,53 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractException = void 0;
+var common_1 = require("@nestjs/common");
+var logger_service_1 = require("../services/logger.service");
+var AbstractException = (function () {
+    function AbstractException() {
+    }
+    AbstractException.prototype.catch = function (exception, host) {
+        this.host = host;
+        var ctx = this.host.switchToHttp();
+        this.response = ctx.getResponse();
+        this.request = ctx.getRequest();
+        this.$logger.error(exception);
+        var handledError = this.handleError(exception);
+        if (handledError instanceof common_1.HttpException) {
+            var trace = exception.getResponse().message;
+            this.response.statusMessage = handledError.name
+                .slice(0, -9)
+                .replace(/([A-Z])/g, ' $1')
+                .trim();
+            return this.response
+                .status(handledError.getStatus())
+                .json({
+                statusCode: handledError.getStatus(),
+                message: handledError.message,
+                error: this.response.statusMessage,
+                trace: trace,
+            });
+        }
+        return this.response
+            .status(500)
+            .json(new common_1.InternalServerErrorException(handledError));
+    };
+    __decorate([
+        (0, common_1.Inject)(),
+        __metadata("design:type", logger_service_1.LoggerService)
+    ], AbstractException.prototype, "$logger", void 0);
+    AbstractException = __decorate([
+        (0, common_1.Injectable)()
+    ], AbstractException);
+    return AbstractException;
+}());
+exports.AbstractException = AbstractException;

package/.output/exceptions/missing-identity.exception.d.ts

@@ -0,0 +1,5 @@
+import { PreconditionFailedException } from '@nestjs/common';
+export declare class MissingIdentityException extends PreconditionFailedException {
+    constructor();
+    static throw(): void;
+}

package/.output/{modules/setting/organization/organization.entity.js → exceptions/missing-identity.exception.js}

@@ -15,14 +15,16 @@ var __extends = (this && this.__extends) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OrganizationEntity = void 0;
-var abstract_entity_1 = require("../../../abstract/abstract.entity");
-var OrganizationEntity = (function (_super) {
-    __extends(OrganizationEntity, _super);
-    function OrganizationEntity() {
-        return _super !== null && _super.apply(this, arguments) || this;
+exports.MissingIdentityException = void 0;
+var common_1 = require("@nestjs/common");
+var MissingIdentityException = (function (_super) {
+    __extends(MissingIdentityException, _super);
+    function MissingIdentityException() {
+        return _super.call(this, 'Missing identity parameter on your request') || this;
     }
-    OrganizationEntity.$index = 'setting_organization';
-    return OrganizationEntity;
-}(abstract_entity_1.AbstractEntity));
-exports.OrganizationEntity = OrganizationEntity;
+    MissingIdentityException.throw = function () {
+        throw new MissingIdentityException;
+    };
+    return MissingIdentityException;
+}(common_1.PreconditionFailedException));
+exports.MissingIdentityException = MissingIdentityException;

package/.output/exceptions/store-not-implemented.exception.d.ts

@@ -0,0 +1,5 @@
+import { NotFoundException } from '@nestjs/common';
+export declare class StoreNotImplementedException extends NotFoundException {
+    constructor(identity: string);
+    static throw(identity: string): void;
+}

package/.output/exceptions/store-not-implemented.exception.js

@@ -0,0 +1,31 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StoreNotImplementedException = void 0;
+var common_1 = require("@nestjs/common");
+var StoreNotImplementedException = (function (_super) {
+    __extends(StoreNotImplementedException, _super);
+    function StoreNotImplementedException(identity) {
+        return _super.call(this, "No store found by that id or name: [" + identity + "]") || this;
+    }
+    StoreNotImplementedException.throw = function (identity) {
+        common_1.Logger.warn('Store not found or implemented', identity);
+        throw new StoreNotImplementedException(identity);
+    };
+    return StoreNotImplementedException;
+}(common_1.NotFoundException));
+exports.StoreNotImplementedException = StoreNotImplementedException;

package/.output/exceptions/store-not-recognized.exception.d.ts

@@ -0,0 +1,5 @@
+import { NotAcceptableException } from '@nestjs/common/exceptions/not-acceptable.exception';
+export declare class StoreNotRecognizedException extends NotAcceptableException {
+    constructor();
+    static throw(): void;
+}

package/.output/exceptions/store-not-recognized.exception.js

@@ -0,0 +1,30 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StoreNotRecognizedException = void 0;
+var not_acceptable_exception_1 = require("@nestjs/common/exceptions/not-acceptable.exception");
+var StoreNotRecognizedException = (function (_super) {
+    __extends(StoreNotRecognizedException, _super);
+    function StoreNotRecognizedException() {
+        return _super.call(this, "The store could not be accepted") || this;
+    }
+    StoreNotRecognizedException.throw = function () {
+        throw new StoreNotRecognizedException();
+    };
+    return StoreNotRecognizedException;
+}(not_acceptable_exception_1.NotAcceptableException));
+exports.StoreNotRecognizedException = StoreNotRecognizedException;

package/.output/modules/inventory/brands/brand.exception.d.ts

@@ -0,0 +1,5 @@
+import { HttpException } from '@nestjs/common';
+import { AbstractException } from '../../../abstract/abstract.exception';
+export declare class BrandException extends AbstractException {
+    handleError(exception: HttpException): HttpException;
+}

package/.output/modules/{setting/theme/theme.entity.js → inventory/brands/brand.exception.js}

@@ -20,27 +20,21 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ThemeEntity = void 0;
-var mongoose_1 = require("@nestjs/mongoose");
-var mongoose_2 = require("mongoose");
-var abstract_entity_1 = require("../../../abstract/abstract.entity");
-var ThemeEntity = (function (_super) {
-    __extends(ThemeEntity, _super);
-    function ThemeEntity() {
+exports.BrandException = void 0;
+var common_1 = require("@nestjs/common");
+var abstract_exception_1 = require("../../../abstract/abstract.exception");
+var BrandException = (function (_super) {
+    __extends(BrandException, _super);
+    function BrandException() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
-    ThemeEntity.$index = 'settings_theme';
-    __decorate([
-        (0, mongoose_1.Prop)({ type: mongoose_2.Schema.Types.String, required: true, unique: true, length: 128 }),
-        __metadata("design:type", String)
-    ], ThemeEntity.prototype, "path", void 0);
-    ThemeEntity = __decorate([
-        (0, mongoose_1.Schema)({ timestamps: true })
-    ], ThemeEntity);
-    return ThemeEntity;
-}(abstract_entity_1.AbstractEntity));
-exports.ThemeEntity = ThemeEntity;
+    BrandException.prototype.handleError = function (exception) {
+        return exception;
+    };
+    BrandException = __decorate([
+        (0, common_1.Catch)()
+    ], BrandException);
+    return BrandException;
+}(abstract_exception_1.AbstractException));
+exports.BrandException = BrandException;

package/.output/modules/inventory/categories/category.exception.d.ts

@@ -0,0 +1,5 @@
+import { HttpException } from '@nestjs/common';
+import { AbstractException } from '../../../abstract/abstract.exception';
+export declare class CategoryException extends AbstractException {
+    handleError(exception: HttpException): HttpException;
+}

package/.output/modules/{setting/layout/layout.entity.js → inventory/categories/category.exception.js}

@@ -20,27 +20,21 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LayoutEntity = void 0;
-var mongoose_1 = require("@nestjs/mongoose");
-var mongoose_2 = require("mongoose");
-var abstract_entity_1 = require("../../../abstract/abstract.entity");
-var LayoutEntity = (function (_super) {
-    __extends(LayoutEntity, _super);
-    function LayoutEntity() {
+exports.CategoryException = void 0;
+var common_1 = require("@nestjs/common");
+var abstract_exception_1 = require("../../../abstract/abstract.exception");
+var CategoryException = (function (_super) {
+    __extends(CategoryException, _super);
+    function CategoryException() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
-    LayoutEntity.$index = 'settings_layout';
-    __decorate([
-        (0, mongoose_1.Prop)({ type: mongoose_2.Schema.Types.String, required: true, unique: true, length: 128 }),
-        __metadata("design:type", String)
-    ], LayoutEntity.prototype, "path", void 0);
-    LayoutEntity = __decorate([
-        (0, mongoose_1.Schema)({ timestamps: true })
-    ], LayoutEntity);
-    return LayoutEntity;
-}(abstract_entity_1.AbstractEntity));
-exports.LayoutEntity = LayoutEntity;
+    CategoryException.prototype.handleError = function (exception) {
+        return exception;
+    };
+    CategoryException = __decorate([
+        (0, common_1.Catch)()
+    ], CategoryException);
+    return CategoryException;
+}(abstract_exception_1.AbstractException));
+exports.CategoryException = CategoryException;

package/.output/modules/inventory/products/product.entity.d.ts

@@ -20,5 +20,6 @@ export declare class ProductEntity extends AbstractEntity {
     code: CodeEntity;
     dimension: DimensionEntity;
     seo: SeoEntity;
+    stock: number;
     readonly picture: string;
 }

package/.output/modules/inventory/products/product.exception.d.ts

@@ -0,0 +1,5 @@
+import { HttpException } from '@nestjs/common';
+import { AbstractException } from '../../../abstract/abstract.exception';
+export declare class ProductException extends AbstractException {
+    handleError(exception: HttpException): HttpException;
+}

package/.output/modules/inventory/products/{entities/price.entity.js → product.exception.js}

@@ -20,30 +20,21 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PriceEntity = void 0;
-var mongoose_1 = require("@nestjs/mongoose");
-var schema_decorator_1 = require("@nestjs/mongoose/dist/decorators/schema.decorator");
-var mongoose_2 = require("mongoose");
-var PriceEntity = (function (_super) {
-    __extends(PriceEntity, _super);
-    function PriceEntity() {
+exports.ProductException = void 0;
+var common_1 = require("@nestjs/common");
+var abstract_exception_1 = require("../../../abstract/abstract.exception");
+var ProductException = (function (_super) {
+    __extends(ProductException, _super);
+    function ProductException() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
-    __decorate([
-        (0, mongoose_1.Prop)({ type: mongoose_2.Schema.Types.Number, required: true }),
-        __metadata("design:type", Number)
-    ], PriceEntity.prototype, "sale", void 0);
-    __decorate([
-        (0, mongoose_1.Prop)({ type: mongoose_2.Schema.Types.Number }),
-        __metadata("design:type", Number)
-    ], PriceEntity.prototype, "purchase", void 0);
-    PriceEntity = __decorate([
-        (0, schema_decorator_1.Schema)()
-    ], PriceEntity);
-    return PriceEntity;
-}(Map));
-exports.PriceEntity = PriceEntity;
+    ProductException.prototype.handleError = function (exception) {
+        return exception;
+    };
+    ProductException = __decorate([
+        (0, common_1.Catch)()
+    ], ProductException);
+    return ProductException;
+}(abstract_exception_1.AbstractException));
+exports.ProductException = ProductException;

package/.output/modules/inventory/products/product.validator.d.ts

@@ -3,7 +3,7 @@ import { ProductCodeValidator } from './validators/code.validator';
 import { ProductDimensionValidator } from './validators/dimension.validator';
 import { ProductPriceValidator } from './validators/price.validator';
 import { ProductSeoValidator } from './validators/seo.validator';
-import { AbstractValidator } from "../../../abstract/abstract.validator";
+import { AbstractValidator } from '../../../abstract/abstract.validator';
 export declare class CreateProductValidator extends AbstractValidator {
     name: string;
     description: string;
@@ -17,6 +17,7 @@ export declare class CreateProductValidator extends AbstractValidator {
     seo: ProductSeoValidator;
     dimension: ProductDimensionValidator;
     code: ProductCodeValidator;
+    stock: number | null;
 }
 export declare class UpdateProductValidator extends CreateProductValidator {
     name: string;

package/.output/modules/inventory/products/product.validator.js

@@ -49,6 +49,7 @@ var CreateProductValidator = (function (_super) {
         _this.seo = new seo_validator_1.ProductSeoValidator();
         _this.dimension = new dimension_validator_1.ProductDimensionValidator();
         _this.code = new code_validator_1.ProductCodeValidator();
+        _this.stock = null;
         return _this;
     }
     __decorate([
@@ -110,6 +111,12 @@ var CreateProductValidator = (function (_super) {
         (0, class_transformer_1.Type)(function () { return code_validator_1.ProductCodeValidator; }),
         __metadata("design:type", Object)
     ], CreateProductValidator.prototype, "code", void 0);
+    __decorate([
+        (0, class_validator_1.IsNumber)(),
+        (0, class_validator_1.IsOptional)(),
+        (0, class_validator_1.Min)(0),
+        __metadata("design:type", Number)
+    ], CreateProductValidator.prototype, "stock", void 0);
     return CreateProductValidator;
 }(abstract_validator_1.AbstractValidator));
 exports.CreateProductValidator = CreateProductValidator;

package/.output/modules/inventory/properties/property.exception.d.ts

@@ -0,0 +1,5 @@
+import { HttpException } from '@nestjs/common';
+import { AbstractException } from '../../../abstract/abstract.exception';
+export declare class PropertyException extends AbstractException {
+    handleError(exception: HttpException): HttpException;
+}

package/.output/modules/inventory/{brands/brand.entity.js → properties/property.exception.js}

@@ -20,31 +20,21 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BrandEntity = void 0;
-var mongoose_1 = require("@nestjs/mongoose");
-var mongoose_2 = require("mongoose");
-var abstract_entity_1 = require("../../../abstract/abstract.entity");
-var BrandEntity = (function (_super) {
-    __extends(BrandEntity, _super);
-    function BrandEntity() {
+exports.PropertyException = void 0;
+var common_1 = require("@nestjs/common");
+var abstract_exception_1 = require("../../../abstract/abstract.exception");
+var PropertyException = (function (_super) {
+    __extends(PropertyException, _super);
+    function PropertyException() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
-    BrandEntity.$index = 'inventory_brands';
-    __decorate([
-        (0, mongoose_1.Prop)({ type: mongoose_2.Schema.Types.String, required: true, unique: true, length: 32 }),
-        __metadata("design:type", String)
-    ], BrandEntity.prototype, "name", void 0);
-    __decorate([
-        (0, mongoose_1.Prop)({ type: mongoose_2.Schema.Types.String }),
-        __metadata("design:type", String)
-    ], BrandEntity.prototype, "description", void 0);
-    BrandEntity = __decorate([
-        (0, mongoose_1.Schema)({ timestamps: true })
-    ], BrandEntity);
-    return BrandEntity;
-}(abstract_entity_1.AbstractEntity));
-exports.BrandEntity = BrandEntity;
+    PropertyException.prototype.handleError = function (exception) {
+        return exception;
+    };
+    PropertyException = __decorate([
+        (0, common_1.Catch)()
+    ], PropertyException);
+    return PropertyException;
+}(abstract_exception_1.AbstractException));
+exports.PropertyException = PropertyException;

package/.output/modules/sales/clients/client.exception.d.ts

@@ -0,0 +1,5 @@
+import { HttpException } from '@nestjs/common';
+import { AbstractException } from '../../../abstract/abstract.exception';
+export declare class ClientException extends AbstractException {
+    handleError(exception: HttpException): HttpException;
+}

package/.output/modules/sales/clients/client.exception.js

@@ -0,0 +1,40 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientException = void 0;
+var common_1 = require("@nestjs/common");
+var abstract_exception_1 = require("../../../abstract/abstract.exception");
+var ClientException = (function (_super) {
+    __extends(ClientException, _super);
+    function ClientException() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    ClientException.prototype.handleError = function (exception) {
+        return exception;
+    };
+    ClientException = __decorate([
+        (0, common_1.Catch)()
+    ], ClientException);
+    return ClientException;
+}(abstract_exception_1.AbstractException));
+exports.ClientException = ClientException;

package/.output/modules/sales/orders/order.exception.d.ts

@@ -0,0 +1,13 @@
+import { NotAcceptableException } from '@nestjs/common/exceptions/not-acceptable.exception';
+import { ItemEntity } from './item/item.entity';
+export declare class OrderWithUnavailableProduct extends NotAcceptableException {
+    readonly items: ItemEntity[];
+    readonly message = "Some products are not available";
+    readonly name: string;
+    constructor(items: ItemEntity[]);
+    getResponse(): {
+        items: ItemEntity[];
+        message: string;
+        name: string;
+    };
+}

package/.output/modules/sales/orders/order.exception.js

@@ -0,0 +1,46 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderWithUnavailableProduct = void 0;
+var not_acceptable_exception_1 = require("@nestjs/common/exceptions/not-acceptable.exception");
+var OrderWithUnavailableProduct = (function (_super) {
+    __extends(OrderWithUnavailableProduct, _super);
+    function OrderWithUnavailableProduct(items) {
+        var _this = _super.call(this) || this;
+        _this.items = [];
+        _this.message = 'Some products are not available';
+        _this.name = OrderWithUnavailableProduct.name;
+        _this.items = items;
+        return _this;
+    }
+    OrderWithUnavailableProduct.prototype.getResponse = function () {
+        return __assign(__assign({}, _super.prototype.getResponse.call(this)), { items: this.items, message: this.message, name: this.name });
+    };
+    return OrderWithUnavailableProduct;
+}(not_acceptable_exception_1.NotAcceptableException));
+exports.OrderWithUnavailableProduct = OrderWithUnavailableProduct;

package/.output/services/logger.service.d.ts

@@ -0,0 +1,11 @@
+import { LoggerService as NestLogger } from '@nestjs/common';
+import { Request } from 'express';
+export declare class LoggerService implements NestLogger {
+    protected readonly $request: Request;
+    protected get organization(): any;
+    log(message: string): void;
+    error(reason: Error): void;
+    warn(message: string, scope?: string): void;
+    debug(message: string, scope?: string): void;
+    verbose(message: string, scope?: string): void;
+}

package/.output/services/logger.service.js

@@ -0,0 +1,54 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerService = void 0;
+var common_1 = require("@nestjs/common");
+var core_1 = require("@nestjs/core");
+var LoggerService = (function () {
+    function LoggerService() {
+    }
+    Object.defineProperty(LoggerService.prototype, "organization", {
+        get: function () {
+            var _a;
+            var session = this.$request.session;
+            if (!session) {
+                return;
+            }
+            return ((_a = session.organization) === null || _a === void 0 ? void 0 : _a.name) || '';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    LoggerService.prototype.log = function (message) {
+        return common_1.Logger.log(message, this.organization);
+    };
+    LoggerService.prototype.error = function (reason) {
+        return common_1.Logger.error("[" + reason.name + "]: " + reason.message, this.organization);
+    };
+    LoggerService.prototype.warn = function (message, scope) {
+        return common_1.Logger.warn("[" + scope + "]: " + message, this.organization);
+    };
+    LoggerService.prototype.debug = function (message, scope) {
+        return common_1.Logger.debug("[" + scope + "]: " + message, this.organization);
+    };
+    LoggerService.prototype.verbose = function (message, scope) {
+        return common_1.Logger.verbose("[" + scope + "]: " + message, this.organization);
+    };
+    __decorate([
+        (0, common_1.Inject)(core_1.REQUEST),
+        __metadata("design:type", Object)
+    ], LoggerService.prototype, "$request", void 0);
+    LoggerService = __decorate([
+        (0, common_1.Injectable)()
+    ], LoggerService);
+    return LoggerService;
+}());
+exports.LoggerService = LoggerService;

package/.output/types.d.ts

@@ -1,4 +1,4 @@
-import { AppMetadata, User, UserMetadata } from 'auth0';
+import { AppMetadata, OrganizationConnection, User, UserMetadata } from 'auth0';
 export interface MetaAddress {
     city: string;
     code: string;
@@ -8,6 +8,9 @@ export interface MetaAddress {
     state: string;
     street: string;
 }
+export interface LocalOrganization extends OrganizationConnection {
+    connected: boolean;
+}
 export interface UserMeta extends UserMetadata {
     addresses?: MetaAddress[];
 }