@aifabrix/builder 2.10.0 → 2.10.1

package/lib/app-config.js

@@ -46,23 +46,54 @@ async function generateVariablesYamlFile(appPath, appName, config) {
   }
 }
 
+/**
+ * Generates env.template content for external systems based on authentication type
+ * @param {Object} config - Application configuration with authType and systemKey
+ * @param {string} appName - Application name (used as fallback for systemKey)
+ * @returns {string} Environment template content
+ */
+function generateExternalSystemEnvTemplate(config, appName) {
+  const systemKey = config.systemKey || appName;
+  const authType = config.authType || 'apikey';
+  const lines = [
+    `# ${systemKey} ${authType.toUpperCase()} Configuration`,
+    '# These values are set via the Miso Controller interface or Dataplane portal',
+    '# Values are stored in Key Vault automatically by the platform',
+    ''
+  ];
+
+  if (authType === 'oauth2') {
+    lines.push('CLIENTID=kv://' + systemKey + '-clientidKeyVault');
+    lines.push('CLIENTSECRET=kv://' + systemKey + '-clientsecretKeyVault');
+    lines.push('TOKENURL=https://api.example.com/oauth/token');
+    lines.push('REDIRECT_URI=kv://' + systemKey + '-redirect-uriKeyVault');
+  } else if (authType === 'apikey') {
+    lines.push('API_KEY=kv://' + systemKey + '-api-keyKeyVault');
+  } else if (authType === 'basic') {
+    lines.push('USERNAME=kv://' + systemKey + '-usernameKeyVault');
+    lines.push('PASSWORD=kv://' + systemKey + '-passwordKeyVault');
+  }
+
+  return lines.join('\n');
+}
+
 /**
  * Generates env.template file if it doesn't exist
  * @async
  * @param {string} appPath - Path to application directory
+ * @param {string} appName - Application name
  * @param {Object} config - Application configuration
  * @param {Object} existingEnv - Existing environment variables
  */
-async function generateEnvTemplateFile(appPath, config, existingEnv) {
-  // Skip env.template for external type
-  if (config.type === 'external') {
-    return;
-  }
-
+async function generateEnvTemplateFile(appPath, appName, config, existingEnv) {
   const envTemplatePath = path.join(appPath, 'env.template');
   if (!(await fileExists(envTemplatePath))) {
     let envTemplate;
-    if (existingEnv) {
+
+    if (config.type === 'external') {
+      // Generate env.template for external systems based on authType
+      envTemplate = generateExternalSystemEnvTemplate(config, appName);
+    } else if (existingEnv) {
       const envResult = await generateEnvTemplateFromReader(config, existingEnv);
       envTemplate = envResult.template;
 
@@ -155,7 +186,7 @@ async function generateDeployJsonFile(appPath, appName, config) {
 async function generateConfigFiles(appPath, appName, config, existingEnv) {
   try {
     await generateVariablesYamlFile(appPath, appName, config);
-    await generateEnvTemplateFile(appPath, config, existingEnv);
+    await generateEnvTemplateFile(appPath, appName, config, existingEnv);
     await generateRbacYamlFile(appPath, appName, config);
     await generateDeployJsonFile(appPath, appName, config);
     await generateReadmeMdFile(appPath, appName, config);

package/lib/app-register.js

@@ -21,6 +21,7 @@ const { updateEnvTemplate } = require('./utils/env-template');
 const { getOrRefreshDeviceToken } = require('./utils/token-manager');
 const { detectAppType } = require('./utils/paths');
 const { generateEnvFile } = require('./secrets');
+const applicationSchema = require('./schema/application-schema.json');
 
 // Import createApp to auto-generate config if missing
 let createApp;
@@ -30,8 +31,17 @@ try {
   createApp = null;
 }
 
+// Extract valid enum values from application schema
+const validTypes = applicationSchema.properties.type.enum || [];
+const validRegistryModes = applicationSchema.properties.registryMode.enum || [];
+const portConstraints = {
+  minimum: applicationSchema.properties.port?.minimum || 1,
+  maximum: applicationSchema.properties.port?.maximum || 65535
+};
+
 /**
  * Validation schema for application registration
+ * Validates according to application-schema.json
  */
 const registerApplicationSchema = {
   environmentId: (val) => {
@@ -44,10 +54,12 @@ const registerApplicationSchema = {
     if (!val || val.length < 1) {
       throw new Error('Application key is required');
     }
-    if (val.length > 50) {
-      throw new Error('Application key must be at most 50 characters');
+    const keyPattern = applicationSchema.properties.key.pattern;
+    const keyMaxLength = applicationSchema.properties.key.maxLength || 50;
+    if (val.length > keyMaxLength) {
+      throw new Error(`Application key must be at most ${keyMaxLength} characters`);
     }
-    if (!/^[a-z0-9-]+$/.test(val)) {
+    if (keyPattern && !new RegExp(keyPattern).test(val)) {
       throw new Error('Application key must contain only lowercase letters, numbers, and hyphens');
     }
     return val;
@@ -56,25 +68,28 @@ const registerApplicationSchema = {
     if (!val || val.length < 1) {
       throw new Error('Display name is required');
     }
-    if (val.length > 100) {
-      throw new Error('Display name must be at most 100 characters');
+    const displayNameMaxLength = applicationSchema.properties.displayName.maxLength || 100;
+    if (val.length > displayNameMaxLength) {
+      throw new Error(`Display name must be at most ${displayNameMaxLength} characters`);
     }
     return val;
   },
   description: (val) => val || undefined,
   configuration: (val) => {
-    const validTypes = ['webapp', 'api', 'service', 'functionapp'];
-    const validRegistryModes = ['acr', 'external', 'public'];
-
     if (!val || !val.type || !validTypes.includes(val.type)) {
-      throw new Error('Configuration type must be one of: webapp, api, service, functionapp');
+      throw new Error(`Configuration type must be one of: ${validTypes.join(', ')}`);
     }
     if (!val.registryMode || !validRegistryModes.includes(val.registryMode)) {
-      throw new Error('Registry mode must be one of: acr, external, public');
+      throw new Error(`Registry mode must be one of: ${validRegistryModes.join(', ')}`);
     }
-    if (val.port !== undefined) {
-      if (!Number.isInteger(val.port) || val.port < 1 || val.port > 65535) {
-        throw new Error('Port must be an integer between 1 and 65535');
+    // Port validation: skip for external type (external systems don't need ports)
+    // For other types, port is required and must be valid
+    if (val.type !== 'external') {
+      if (val.port === undefined || val.port === null) {
+        throw new Error('Port is required for non-external application types');
+      }
+      if (!Number.isInteger(val.port) || val.port < portConstraints.minimum || val.port > portConstraints.maximum) {
+        throw new Error(`Port must be an integer between ${portConstraints.minimum} and ${portConstraints.maximum}`);
       }
     }
     return val;

package/lib/templates.js

@@ -20,11 +20,16 @@ function generateVariablesYaml(appName, config) {
 
   // For external type, create minimal variables.yaml
   if (appType === 'external') {
+    // Use config values if provided, otherwise use defaults consistent with prompts
+    const systemKey = config.systemKey || appName;
+    const systemDisplayName = config.systemDisplayName || displayName;
+    const systemDescription = config.systemDescription || `External system integration for ${appName}`;
+
     const variables = {
       app: {
-        key: appName,
-        displayName: displayName,
-        description: `${appName.replace(/-/g, ' ')} external system`,
+        key: systemKey,
+        displayName: systemDisplayName,
+        description: systemDescription,
         type: 'external'
       },
       deployment: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aifabrix/builder",
-  "version": "2.10.0",
+  "version": "2.10.1",
   "description": "AI Fabrix Local Fabric & Deployment SDK",
   "main": "lib/index.js",
   "bin": {