@omnia/tooling-composers 8.0.348-dev → 8.0.350-dev

package/internal-do-not-import-from-here/Composer.d.ts

@@ -6,6 +6,7 @@ import { IManifestGroupComposer } from "./ManifestGroupComposer";
 import { IRegisterService } from './ServiceComposer';
 import { guid } from '../../fx-models';
 import { IClientServiceConfigurator } from '.';
+import { IServiceFeatureComposer } from "./ServiceFeatureComposer";
 export interface IComposerDone<T> {
     done: () => T;
 }
@@ -41,7 +42,7 @@ export interface INewManifestComposer extends IRegisterService {
     * @param lcid the language..
     */
     registerLocalization: (localizationOptions?: LocalizationOptions) => ILocalizationComposer;
-    registerFeature: (options: ServiceFeatureOption) => void;
+    registerFeature: (options: ServiceFeatureOption) => IServiceFeatureComposer;
     registerAppDefinition: (options: ServiceAppDefinitionOption) => void;
     registerRoleDefinition: (option: ServiceRoleDefinitionOption) => void;
 }

package/internal-do-not-import-from-here/Composer.js

@@ -8,11 +8,11 @@ const LocalizationComposer_1 = require("./LocalizationComposer");
 const Utils_1 = require("./Utils");
 const ManifestGroupComposer_1 = require("./ManifestGroupComposer");
 const ServiceComposer_1 = require("./ServiceComposer");
-const ServiceFeatureRegistry_1 = require("./ServiceFeatureRegistry");
 const ServiceAppRegistry_1 = require("./ServiceAppRegistry");
 const ServiceRoleRegistry_1 = require("./ServiceRoleRegistry");
 const ImportManifestRegistry_1 = require("./ImportManifestRegistry");
 const _1 = require(".");
+const ServiceFeatureComposer_1 = require("./ServiceFeatureComposer");
 class NewManifestComposer {
     constructor(manifestId, manifestName) {
         this.manifestId = manifestId;
@@ -30,7 +30,7 @@ class NewManifestComposer {
             return new LocalizationComposer_1.Localization(localizationOptions, this.manifestId);
         };
         this.registerFeature = (options) => {
-            ServiceFeatureRegistry_1.ServiceFeatureRegistry.AddFeature(this.manifestId, options);
+            return new ServiceFeatureComposer_1.ServiceFeatureComposer(this.manifestId, options);
         };
         this.registerAppDefinition = (options) => {
             ServiceAppRegistry_1.ServiceAppRegistry.AddAppDefinition(this.manifestId, options);

package/internal-do-not-import-from-here/ServiceFeatureComposer.d.ts

@@ -1,9 +1,26 @@
-import { ServiceFeatureOption } from './models/index';
-export interface IServiceFeatureComposer<T> {
+import { guid } from '@omnia/fx-models';
+import { IServiceManifestComposer } from './ServiceManifestComposer';
+import { OnTheFlyServiceRequest, PersistentDiskResourceOption, ServiceFeatureOption, SqlElasticPoolResourceOption, SqlResourceOption } from './models/index';
+export interface IServiceFeatureComposer extends Omit<IServiceManifestComposer<IServiceFeatureComposer>, "requireAzureAdAppPermissions" | "isOnTheFlyService"> {
+    requestOnTheFlyService: (onTheFlyService: OnTheFlyServiceRequest) => IServiceFeatureComposer;
+}
+export declare class ServiceFeatureComposer implements IServiceFeatureComposer {
+    private featureId;
+    private option;
+    constructor(featureId: guid, option: ServiceFeatureOption);
+    private AddFeature;
+    /**
+     *   Request an SQL database when feature activated
+     */
+    requestSqlDatabase: (options: SqlResourceOption) => this;
+    /**
+     *  Request a Persistent Disk for storing files when feature activated
+     */
+    requestPersistentDisk: (options: PersistentDiskResourceOption) => this;
     /**
-    * Add a feature for this omnia service
-    *
-    * @param options the options for defining a feature.
-    */
-    AddFeature: (options: ServiceFeatureOption) => T;
+     *  Request an SQL database using shared Elastic Pool when feature activated
+     */
+    requestSqlElasticPoolDatabase: (options: SqlElasticPoolResourceOption) => this;
+    requestOnTheFlyService: (onTheFlyService: OnTheFlyServiceRequest) => this;
+    private addRequestedResource;
 }

package/internal-do-not-import-from-here/ServiceFeatureComposer.js

@@ -1,2 +1,89 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceFeatureComposer = void 0;
+const tslib_1 = require("tslib");
+const fx_models_1 = require("@omnia/fx-models");
+const AzureAdAppPermissionHelper_1 = require("./AzureAdAppPermissionHelper");
+const ManifestRegistry_1 = require("./ManifestRegistry");
+const ServiceFeatureRegistry_1 = require("./ServiceFeatureRegistry");
+const index_1 = require("./models/index");
+const deep_extend_1 = tslib_1.__importDefault(require("deep-extend"));
+class ServiceFeatureComposer {
+    constructor(featureId, option) {
+        this.featureId = featureId;
+        this.option = option;
+        this.AddFeature = (featureId, option) => {
+            let manifest = {
+                manifestType: index_1.ServerManifestTypes.ServiceFeature
+            };
+            let featureManifest = (0, deep_extend_1.default)(manifest, option);
+            featureManifest.uniqueId = featureId;
+            featureManifest.requiresAzureAdAppPermissions = AzureAdAppPermissionHelper_1.AzureAdAppPermissionHelper.getAzureAdAppPermissions(option.requiresAzureAdAppPermissions);
+            ServiceFeatureRegistry_1.ServiceFeatureRegistry.AddFeatureManifest(featureManifest);
+            return this;
+        };
+        /**
+         *   Request an SQL database when feature activated
+         */
+        this.requestSqlDatabase = (options) => {
+            let manifest = {
+                manifestType: index_1.ServerManifestTypes.ResourceRequest,
+                resourceType: index_1.RequestedResourceTypes.SqlDatabase
+            };
+            const sqlResourceManifest = (0, deep_extend_1.default)(manifest, options);
+            this.addRequestedResource(sqlResourceManifest, this.featureId);
+            return this;
+        };
+        /**
+         *  Request a Persistent Disk for storing files when feature activated
+         */
+        this.requestPersistentDisk = (options) => {
+            const manifest = {
+                manifestType: index_1.ServerManifestTypes.ResourceRequest,
+                resourceType: index_1.RequestedResourceTypes.PersistentDisk
+            };
+            const persistentDiskResourceManifest = (0, deep_extend_1.default)(manifest, options);
+            this.addRequestedResource(persistentDiskResourceManifest, this.featureId);
+            return this;
+        };
+        /**
+         *  Request an SQL database using shared Elastic Pool when feature activated
+         */
+        this.requestSqlElasticPoolDatabase = (options) => {
+            const manifest = {
+                manifestType: index_1.ServerManifestTypes.ResourceRequest,
+                resourceType: index_1.RequestedResourceTypes.SqlElasticPoolDatabase
+            };
+            const sqlElasticPoolResourceManifest = (0, deep_extend_1.default)(manifest, options);
+            this.addRequestedResource(sqlElasticPoolResourceManifest, this.featureId);
+            return this;
+        };
+        this.requestOnTheFlyService = (onTheFlyService) => {
+            const featureManifest = ServiceFeatureRegistry_1.ServiceFeatureRegistry.GetFeatureManifest(this.featureId);
+            if (!Array.isArray(featureManifest.requestedOnTheFlyServices)) {
+                featureManifest.requestedOnTheFlyServices = [];
+            }
+            const existed = featureManifest.requestedOnTheFlyServices.find(x => x.serviceId.toString() === onTheFlyService.serviceId.toString());
+            if (existed) {
+                throw new Error(`On the fly service with id ${onTheFlyService.serviceId} has already been added to the feature.`);
+            }
+            featureManifest.requestedOnTheFlyServices.push(onTheFlyService);
+            return this;
+        };
+        if (featureId == fx_models_1.emptyGuid) {
+            throw new Error("Can't add feature with id: Guid.empty. See manifest file: " + ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath());
+        }
+        if (ServiceFeatureRegistry_1.ServiceFeatureRegistry.FeatureExisted[featureId.toString()]) {
+            throw new Error("Can't add feature id " + featureId + ", a feature with the same id has already been added. See manifest file: " + ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath());
+        }
+        this.AddFeature(featureId, option);
+    }
+    addRequestedResource(requestedResourceManifest, featureId) {
+        const featureManifest = ServiceFeatureRegistry_1.ServiceFeatureRegistry.GetFeatureManifest(featureId);
+        if (!Array.isArray(featureManifest.requestedResources)) {
+            featureManifest.requestedResources = [];
+        }
+        featureManifest.requestedResources.push(requestedResourceManifest);
+    }
+}
+exports.ServiceFeatureComposer = ServiceFeatureComposer;

package/internal-do-not-import-from-here/ServiceFeatureRegistry.d.ts

@@ -1,8 +1,10 @@
-import { ServiceFeatureOption } from './models/index';
+import { ServiceFeatureManifest } from './models/index';
 import { guid } from '../../fx-models';
 export declare class ServiceFeatureRegistry {
     private static AddedFeatures;
-    static AddFeature: (featureId: guid, option: ServiceFeatureOption) => void;
+    static FeatureExisted(featureId: guid): boolean;
+    static AddFeatureManifest(featureManifest: ServiceFeatureManifest): void;
+    static GetFeatureManifest(featureId: guid): ServiceFeatureManifest;
     private static getServerManifests;
     private static clearState;
     private static ServerSubscription;

package/internal-do-not-import-from-here/ServiceFeatureRegistry.js

@@ -1,29 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServiceFeatureRegistry = void 0;
-const tslib_1 = require("tslib");
-const index_1 = require("./models/index");
 const ManifestRegistry_1 = require("./ManifestRegistry");
-const deep_extend_1 = tslib_1.__importDefault(require("deep-extend"));
-const models_1 = require("../../fx-models");
-const AzureAdAppPermissionHelper_1 = require("./AzureAdAppPermissionHelper");
 class ServiceFeatureRegistry {
     static { this.AddedFeatures = {}; }
-    static { this.AddFeature = (featureId, option) => {
-        if (featureId === models_1.emptyGuid) {
-            throw new Error("Can't add feature with id: emptyGuid. See manifest file: " + ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath());
-        }
-        if (ServiceFeatureRegistry.AddedFeatures[featureId.toString()] != null) {
-            throw new Error("Can't add feature id " + featureId + ", a feature with the same id has already been added. See manifest file: " + ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath());
-        }
-        let manifest = {
-            manifestType: index_1.ServerManifestTypes.ServiceFeature
-        };
-        let featureManifest = (0, deep_extend_1.default)(manifest, option);
-        featureManifest.uniqueId = featureId;
-        featureManifest.requiresAzureAdAppPermissions = AzureAdAppPermissionHelper_1.AzureAdAppPermissionHelper.getAzureAdAppPermissions(option.requiresAzureAdAppPermissions);
-        ServiceFeatureRegistry.AddedFeatures[featureId.toString()] = featureManifest;
-    }; }
+    static FeatureExisted(featureId) {
+        return ServiceFeatureRegistry.AddedFeatures[featureId.toString()] != null;
+    }
+    static AddFeatureManifest(featureManifest) {
+        ServiceFeatureRegistry.AddedFeatures[featureManifest.uniqueId.toString()] = featureManifest;
+    }
+    static GetFeatureManifest(featureId) {
+        return ServiceFeatureRegistry.AddedFeatures[featureId.toString()];
+    }
     static { this.getServerManifests = (currentServiceId) => {
         let serverManifests = new Array();
         for (let key in ServiceFeatureRegistry.AddedFeatures) {

package/internal-do-not-import-from-here/models/ServerManifests.d.ts

@@ -88,9 +88,14 @@ export interface ServiceFeatureOption {
      */
     configuration?: IFeatureConfiguration;
 }
+export interface OnTheFlyServiceRequest {
+    serviceId: guid;
+}
 export interface ServiceFeatureManifest extends Omit<ServiceFeatureOption, 'requiresAzureAdAppPermissions'>, ServerManifest {
     uniqueId: guid;
     requiresAzureAdAppPermissions?: AzureAdAppPermissionInfo[];
+    requestedResources?: RequestedResourceManifest[];
+    requestedOnTheFlyServices?: OnTheFlyServiceRequest[];
 }
 export interface AppResourceType {
     id: guid;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@omnia/tooling-composers",
   "license": "MIT",
-  "version": "8.0.348-dev",
+  "version": "8.0.350-dev",
   "description": "Provide tooling to work with manifest things.",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
@@ -19,8 +19,8 @@
   ],
   "author": "Omnia Digital Workplace AB",
   "dependencies": {
-    "@omnia/fx-models": "8.0.348-dev",
-    "@omnia/tooling": "8.0.348-dev",
+    "@omnia/fx-models": "8.0.350-dev",
+    "@omnia/tooling": "8.0.350-dev",
     "deep-extend": "0.6.0",
     "fs-extra": "11.1.0",
     "del": "6.0.0",