@adminide-stack/form-builder-core 5.1.4-alpha.82 → 5.1.6-alpha.1

package/lib/utils/authMetaDataSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"authMetaDataSchema.js","sources":["../../src/utils/authMetaDataSchema.ts"],"sourcesContent":[null],"names":[],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/utils/deepMergeFormSteps.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Deep merge preGeneratedFormSteps arrays by matching step/element ids recursively.
+ * When two steps share the same id (e.g. "credential"), their elements/children are
+ * recursively merged so that all unique template namespaces appear as siblings in the tree.
+ *
+ * This utility lives in core so it can be reused by both browser and server code.
+ */
+export declare function deepMergeFormSteps(existingSteps: any[], newSteps: any[]): any[];
+/**
+ * Recursively merge element/children arrays by matching on element id.
+ * Groups with matching ids have their children merged recursively;
+ * elements with unique ids are appended.
+ */
+export declare function deepMergeElements(existingElements: any[], newElements: any[]): any[];
+//# sourceMappingURL=deepMergeFormSteps.d.ts.map

package/lib/utils/deepMergeFormSteps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deepMergeFormSteps.d.ts","sourceRoot":"","sources":["../../src/utils/deepMergeFormSteps.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,aAAa,EAAE,GAAG,EAAE,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,GAAG,EAAE,CAmB/E;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,gBAAgB,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,GAAG,EAAE,GAAG,GAAG,EAAE,CAyBpF"}

package/lib/utils/deepMergeFormSteps.js

@@ -0,0 +1,64 @@
+/**
+ * Deep merge preGeneratedFormSteps arrays by matching step/element ids recursively.
+ * When two steps share the same id (e.g. "credential"), their elements/children are
+ * recursively merged so that all unique template namespaces appear as siblings in the tree.
+ *
+ * This utility lives in core so it can be reused by both browser and server code.
+ */
+function deepMergeFormSteps(existingSteps, newSteps) {
+  const result = existingSteps.map(step => ({
+    ...step
+  }));
+  for (const newStep of newSteps) {
+    const existingIndex = result.findIndex(s => s.id === newStep.id);
+    if (existingIndex >= 0) {
+      // Same step id — deep merge elements
+      const existing = result[existingIndex];
+      result[existingIndex] = {
+        ...existing,
+        ...newStep,
+        elements: deepMergeElements(existing.elements || [], newStep.elements || [])
+      };
+    } else {
+      result.push({
+        ...newStep
+      });
+    }
+  }
+  return result;
+}
+/**
+ * Recursively merge element/children arrays by matching on element id.
+ * Groups with matching ids have their children merged recursively;
+ * elements with unique ids are appended.
+ */
+function deepMergeElements(existingElements, newElements) {
+  const result = existingElements.map(el => ({
+    ...el
+  }));
+  for (const newEl of newElements) {
+    const existingIndex = result.findIndex(e => e.id === newEl.id);
+    if (existingIndex >= 0) {
+      const existing = result[existingIndex];
+      if (existing.children && newEl.children) {
+        // Both have children — recursively merge
+        result[existingIndex] = {
+          ...existing,
+          ...newEl,
+          children: deepMergeElements(existing.children, newEl.children)
+        };
+      } else if (newEl.children) {
+        // Only new has children — use new
+        result[existingIndex] = {
+          ...newEl
+        };
+      }
+      // If only existing has children or neither has, keep existing
+    } else {
+      result.push({
+        ...newEl
+      });
+    }
+  }
+  return result;
+}export{deepMergeElements,deepMergeFormSteps};//# sourceMappingURL=deepMergeFormSteps.js.map

package/lib/utils/deepMergeFormSteps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deepMergeFormSteps.js","sources":["../../src/utils/deepMergeFormSteps.ts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;;;;;;AAMG;AACH,SAAA,kBAAgB,CAAA,aAAmB,EAAA,QAAe;AAqBlD,EAAA,MAAA,MAAA,GAAA,aAAA,CAAA,GAAA,CAAA,IAAA,KAAA;;;;AAIG,IAAA,MAAA,aAAA,GAAA,MAAA,CAAA,SAAA,CAAA,CAAA,IAAA,CAAA,CAAA,EAAA,KAAA,OAAA,CAAA,EAAA,CAAA;AACH,IAAA,IAAA,aAAA,IAAgB,CAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/utils/schemaHelpers.d.ts

@@ -0,0 +1,85 @@
+export interface FormField {
+    type?: string;
+    title?: string;
+    required?: boolean;
+    enum?: string[];
+    enumNames?: string[];
+    enumLabels?: Array<{
+        key: string;
+        value: string;
+    }>;
+    oneOf?: Array<{
+        const: string;
+        title: string;
+    }>;
+    uniqueItems?: boolean;
+    properties?: Record<string, FormField>;
+    items?: FormField;
+    format?: string;
+    minimum?: number;
+    maximum?: number;
+    $ref?: string;
+    description?: string;
+    discriminator?: {
+        propertyName: string;
+    };
+}
+export interface Definition {
+    type?: string;
+    description?: string;
+    properties?: Record<string, any>;
+}
+export interface CombinedSchema {
+    formSchema?: {
+        type?: string;
+        title?: string;
+        properties?: Record<string, FormField>;
+        required?: string[];
+        $defs?: Record<string, Definition>;
+        definitions?: Record<string, Definition>;
+    };
+    uiSchema?: Record<string, any>;
+    connectionsSchema?: Record<string, any>;
+}
+export type ParsedSampleResult = {
+    mainNodes: any[];
+    mainMetadataNode: any | null;
+    additionalSchemas: Array<{
+        schemaId: string;
+        type: string;
+        formId: string;
+        configurationNodes: any[];
+    }>;
+};
+export declare const FORM_METADATA_NODE_TYPE = "form-metadata";
+export declare enum FormType {
+    CONTRIBUTION = "Contribution",
+    DATABASE_BUILDER = "DatabaseBuilder",
+    MULTI_FORM = "Multi Form"
+}
+export declare enum DatabaseType {
+    POSTGRESQL = "postgresql",
+    MYSQL = "mysql",
+    MONGODB = "mongodb"
+}
+export declare const SCHEMA_ID_OPTIONS: {
+    Contribution: {
+        value: string;
+        label: string;
+    }[];
+    DatabaseBuilder: {
+        label: string;
+        value: string;
+        databaseType: DatabaseType;
+    }[];
+    "Multi Form": {
+        label: string;
+        value: string;
+    }[];
+};
+export declare const isContributionSchemaId: (schemaId: string) => boolean;
+export declare const flattenSchemaWithUiContext: (schema: any, uiSchema?: any, prefix?: string, parentMeta?: any) => Record<string, any>;
+export declare const flattenUiSchema: (uiSchema: any, prefix?: string) => Record<string, any>;
+export declare const flattenSchemas: (schemas: CombinedSchema) => CombinedSchema;
+export declare const parseSampleNodes: (sampleNodes: any[], fallbackSchemaId: string, fallbackType: string) => ParsedSampleResult;
+//# sourceMappingURL=schemaHelpers.d.ts.map

package/lib/utils/schemaHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemaHelpers.d.ts","sourceRoot":"","sources":["../../src/utils/schemaHelpers.ts"],"names":[],"mappings":"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"}

package/lib/utils/schemaHelpers.js

@@ -0,0 +1,473 @@
+import {ContributionSchemaId}from'common';const FORM_METADATA_NODE_TYPE = 'form-metadata';
+var FormType;
+(function (FormType) {
+  FormType["CONTRIBUTION"] = "Contribution";
+  FormType["DATABASE_BUILDER"] = "DatabaseBuilder";
+  FormType["MULTI_FORM"] = "Multi Form";
+  // CREDENTIALS = 'Credentials',
+})(FormType || (FormType = {}));
+var DatabaseType;
+(function (DatabaseType) {
+  DatabaseType["POSTGRESQL"] = "postgresql";
+  DatabaseType["MYSQL"] = "mysql";
+  DatabaseType["MONGODB"] = "mongodb";
+})(DatabaseType || (DatabaseType = {}));
+const SCHEMA_ID_OPTIONS = {
+  [FormType.CONTRIBUTION]: [{
+    value: ContributionSchemaId.UserRole,
+    label: 'User Role'
+  }, {
+    value: ContributionSchemaId.Permission,
+    label: 'Permission'
+  }, {
+    value: ContributionSchemaId.Configuration,
+    label: 'Configuration'
+  }, {
+    value: ContributionSchemaId.Policy,
+    label: 'Policy'
+  }, {
+    value: ContributionSchemaId.UiLayout,
+    label: 'UI Layout'
+  },
+  // Note: Secrets schema removed - use Environment Variable toggle on any element instead
+  {
+    value: 'commands',
+    label: 'Commands'
+  }, {
+    value: 'menus',
+    label: 'Menus'
+  }, {
+    value: ContributionSchemaId.SubscriptionPlan,
+    label: 'Subscription Plan'
+  }],
+  [FormType.DATABASE_BUILDER]: [{
+    label: 'PostgreSQL Database',
+    value: 'postgresql-builder',
+    databaseType: DatabaseType.POSTGRESQL
+  }, {
+    label: 'MySQL Database',
+    value: 'mysql-builder',
+    databaseType: DatabaseType.MYSQL
+  }, {
+    label: 'General Database',
+    value: 'mongodb-builder',
+    databaseType: DatabaseType.MONGODB
+  }],
+  [FormType.MULTI_FORM]: [{
+    label: 'Stepper Form',
+    value: 'stepper-form'
+  }, {
+    label: 'Form Page builder',
+    value: 'form-page-builder'
+  }]
+  // [FormType.CREDENTIALS]: [{ label: 'Credentials', value: 'credentials' }],
+};
+const isContributionSchemaId = schemaId => {
+  const contributionSchemaIds = SCHEMA_ID_OPTIONS[FormType.CONTRIBUTION] || [];
+  return contributionSchemaIds.some(option => option.value === schemaId);
+};
+const isCompositeNumberSelect = (uiSchema, path) => {
+  if (!uiSchema) return false;
+  const pathParts = path.split('.');
+  let current = uiSchema;
+  for (const part of pathParts) {
+    if (!current || !current[part]) return false;
+    current = current[part];
+  }
+  return current && current['ui:field'] === 'CompositeNumberSelectField';
+};
+const flattenSchemaWithUiContext = (schema, uiSchema, prefix = '', parentMeta = {}) => {
+  const result = {};
+  // Debug: Log function entry
+  console.log(`[FlattenSchemaWithUiContext] Entry:`, {
+    prefix,
+    schemaType: typeof schema,
+    isArray: Array.isArray(schema),
+    schemaKeys: schema && typeof schema === 'object' ? Object.keys(schema) : 'not an object',
+    hasProperties: !!schema?.properties,
+    schemaTypeValue: schema?.type,
+    depth: prefix ? prefix.split('.').length : 0
+  });
+  // Handle different schema types
+  if (!schema || typeof schema !== 'object') {
+    console.log(`[FlattenSchemaWithUiContext] Early return - not an object:`, {
+      schema,
+      prefix
+    });
+    return result;
+  }
+  // Special handling for top-level form schema
+  // Handle schemas with type: 'object' and properties, regardless of title
+  // This ensures properties are processed directly without adding 'properties.' prefix
+  const isTopLevelSchema = (schema.type === 'object' && schema.title === 'Dynamic Form' || schema.type === 'object' && schema.properties || Object.keys(schema).length === 1 && schema.properties) && schema.properties && !prefix;
+  console.log(`[FlattenSchemaWithUiContext] Checking top-level condition:`, {
+    prefix,
+    isTopLevelSchema,
+    hasType: !!schema.type,
+    hasProperties: !!schema.properties,
+    title: schema.title,
+    schemaKeys: Object.keys(schema)
+  });
+  if (isTopLevelSchema) {
+    // Extract only the required field
+    if (schema.required) {
+      result.required = schema.required;
+    }
+    // Process properties directly
+    const flattenedProperties = {};
+    Object.keys(schema.properties).forEach((stepKey, idx) => {
+      const stepValue = schema.properties[stepKey];
+      if (stepValue && typeof stepValue === 'object' && stepValue.type === 'object' && stepValue.properties) {
+        // Add .meta key for this group/step
+        const meta = {
+          title: stepValue.title || '',
+          description: stepValue.description || '',
+          type: stepValue.type || 'object',
+          position: idx
+        };
+        // Preserve custom metadata properties for configuration and secret elements
+        if ('fieldMeta' in stepValue) meta['fieldMeta'] = stepValue['fieldMeta'];
+        if ('isSecretElement' in stepValue) meta.isSecretElement = stepValue.isSecretElement;
+        if ('writeOnly' in stepValue) meta.writeOnly = stepValue.writeOnly;
+        if ('databaseField' in stepValue) meta.databaseField = stepValue.databaseField;
+        if ('columnsPerRow' in stepValue) meta.columnsPerRow = stepValue.columnsPerRow;
+        // Preserve schema element flags for elements from configuration/policy schemas
+        if ('isSchemaElement' in stepValue) meta.isSchemaElement = stepValue.isSchemaElement;
+        if ('sourceSchemaId' in stepValue) meta.sourceSchemaId = stepValue.sourceSchemaId;
+        // CRITICAL: Preserve secret/environment variable properties
+        if ('isEnvironmentVariable' in stepValue) meta.isEnvironmentVariable = stepValue.isEnvironmentVariable;
+        if ('secretType' in stepValue) meta.secretType = stepValue.secretType;
+        if ('vaultKeyName' in stepValue) meta.vaultKeyName = stepValue.vaultKeyName;
+        if ('x-env' in stepValue) meta['x-env'] = stepValue['x-env'];
+        // Log secret properties being flattened
+        if (stepValue.isEnvironmentVariable || stepValue['x-env']) {
+          console.log('[flattenSchemaWithUiContext] Step has secret props:', {
+            stepKey,
+            isEnvironmentVariable: stepValue.isEnvironmentVariable,
+            secretType: stepValue.secretType,
+            vaultKeyName: stepValue.vaultKeyName,
+            xEnv: stepValue['x-env'],
+            metaSecretProps: {
+              isEnvironmentVariable: meta.isEnvironmentVariable,
+              secretType: meta.secretType,
+              vaultKeyName: meta.vaultKeyName,
+              xEnv: meta['x-env']
+            }
+          });
+        }
+        flattenedProperties[`${stepKey}.meta`] = meta;
+        if (stepValue.required) {
+          flattenedProperties[`${stepKey}.required`] = stepValue.required;
+        }
+        // Recursively process nested properties with correct uiSchema context
+        const nestedUiSchema = uiSchema?.[stepKey];
+        console.log(`[FlattenSchema] About to recursively process ${stepKey}:`, {
+          inputProperties: stepValue.properties,
+          inputKeys: Object.keys(stepValue.properties || {}),
+          nestedUiSchemaKeys: nestedUiSchema ? Object.keys(nestedUiSchema) : 'no uiSchema',
+          prefix: stepKey
+        });
+        const nestedFlattened = flattenSchemaWithUiContext(stepValue.properties, nestedUiSchema, stepKey);
+        console.log(`[FlattenSchema] Recursive call result for ${stepKey}:`, {
+          inputKeys: Object.keys(stepValue.properties || {}),
+          outputKeys: Object.keys(nestedFlattened),
+          outputKeyCount: Object.keys(nestedFlattened).length,
+          allOutputKeys: Object.keys(nestedFlattened),
+          prefix: stepKey
+        });
+        Object.assign(flattenedProperties, nestedFlattened);
+      } else {
+        flattenedProperties[stepKey] = stepValue;
+      }
+    });
+    // Process $defs if present
+    if (schema.$defs) {
+      const flattenedDefs = {};
+      Object.keys(schema.$defs).forEach(defKey => {
+        const defValue = schema.$defs[defKey];
+        if (defValue && typeof defValue === 'object' && defValue.properties) {
+          Object.keys(defValue.properties).forEach(propKey => {
+            const propValue = defValue.properties[propKey];
+            flattenedDefs[`$defs.${defKey}.${propKey}`] = propValue;
+          });
+        } else {
+          flattenedDefs[`$defs.${defKey}`] = defValue;
+        }
+      });
+      return {
+        ...result,
+        ...flattenedProperties,
+        ...flattenedDefs
+      };
+    }
+    return {
+      ...result,
+      ...flattenedProperties
+    };
+  }
+  // Process each property with composite element detection
+  // This handles nested properties objects (like contributionPoint.properties.categoryName.properties...)
+  // Check if schema is a plain object where all values are objects (not arrays, not null, not primitives)
+  const isPropertiesObject = Object.keys(schema).length > 0 && Object.keys(schema).every(k => typeof schema[k] === 'object' && schema[k] !== null && !Array.isArray(schema[k]) && (schema[k].type !== undefined || schema[k].properties !== undefined || Object.keys(schema[k]).length > 0));
+  if (isPropertiesObject) {
+    console.log(`[FlattenSchema] Entering properties object processing (prefix: ${prefix}):`, {
+      schemaKeys: Object.keys(schema),
+      prefix,
+      depth: prefix ? prefix.split('.').length : 0
+    });
+    const keys = Object.keys(schema);
+    keys.forEach((key, idx) => {
+      // Skip any UI-only keys that may have leaked into the form JSON schema
+      if (key.startsWith('ui:')) {
+        return;
+      }
+      const value = schema[key];
+      const newKey = prefix ? `${prefix}.${key}` : key;
+      if (value && typeof value === 'object' && value.type === 'object' && value.properties) {
+        // Check if this is a compositeNumberSelect element
+        const isComposite = isCompositeNumberSelect(uiSchema, newKey);
+        // Debug logging for nested structure processing
+        console.log(`[FlattenSchema] Processing nested object at path: ${newKey}`, {
+          hasProperties: !!value.properties,
+          propertyKeys: Object.keys(value.properties || {}),
+          prefix,
+          depth: newKey.split('.').length
+        });
+        const meta = {
+          title: value.title || '',
+          description: value.description || '',
+          type: value.type || 'object',
+          position: idx
+        };
+        // Add composite element marker
+        if (isComposite) {
+          meta['x-composite-type'] = 'compositeNumberSelect';
+          console.log(`[FlattenSchema] ✅ Marked as composite: ${newKey}`);
+        }
+        // Preserve custom metadata properties for configuration and secret elements
+        if ('fieldMeta' in value) meta['fieldMeta'] = value['fieldMeta'];
+        if ('isSecretElement' in value) meta.isSecretElement = value.isSecretElement;
+        if ('writeOnly' in value) meta.writeOnly = value.writeOnly;
+        if ('databaseField' in value) meta.databaseField = value.databaseField;
+        if ('columnsPerRow' in value) meta.columnsPerRow = value.columnsPerRow;
+        // Preserve schema element flags for elements from configuration/policy schemas
+        if ('isSchemaElement' in value) meta.isSchemaElement = value.isSchemaElement;
+        if ('sourceSchemaId' in value) meta.sourceSchemaId = value.sourceSchemaId;
+        // CRITICAL: Preserve secret/environment variable properties
+        if ('isEnvironmentVariable' in value) meta.isEnvironmentVariable = value.isEnvironmentVariable;
+        if ('secretType' in value) meta.secretType = value.secretType;
+        if ('vaultKeyName' in value) meta.vaultKeyName = value.vaultKeyName;
+        if ('x-env' in value) meta['x-env'] = value['x-env'];
+        result[`${newKey}.meta`] = meta;
+        if (value.required) {
+          result[`${newKey}.required`] = value.required;
+        }
+        // Recursively process nested properties with correct uiSchema context
+        const nestedUiSchema = uiSchema?.[key];
+        const nestedFlattened = flattenSchemaWithUiContext(value.properties, nestedUiSchema, newKey);
+        console.log(`[FlattenSchema] Recursive result for ${newKey}:`, {
+          inputKeys: Object.keys(value.properties || {}),
+          outputKeys: Object.keys(nestedFlattened),
+          sampleOutputKeys: Object.keys(nestedFlattened).slice(0, 5)
+        });
+        Object.assign(result, nestedFlattened);
+      } else {
+        result[newKey] = value;
+      }
+    });
+    return result;
+  }
+  // Fallback processing - handles cases where schema doesn't match previous conditions
+  console.log(`[FlattenSchemaWithUiContext] Entering fallback processing (prefix: ${prefix}):`, {
+    schemaKeys: Object.keys(schema),
+    prefix,
+    depth: prefix ? prefix.split('.').length : 0,
+    schemaSample: Object.keys(schema).slice(0, 3).reduce((acc, k) => {
+      acc[k] = {
+        type: schema[k]?.type,
+        hasProperties: !!schema[k]?.properties
+      };
+      return acc;
+    }, {})
+  });
+  Object.keys(schema).forEach(key => {
+    // Skip any UI-only keys that may have leaked into the form JSON schema
+    if (key.startsWith('ui:')) {
+      return;
+    }
+    const value = schema[key];
+    const newKey = prefix ? `${prefix}.${key}` : key;
+    if (value && typeof value === 'object' && value.type === 'object' && value.properties) {
+      const isComposite = isCompositeNumberSelect(uiSchema, newKey);
+      // Debug composite detection for troubleshooting (fallback section)
+      console.log(`[FlattenSchema:Fallback] Checking composite for path: ${newKey}`, {
+        isComposite,
+        hasValueProp: !!value.properties?.value,
+        hasTypeProp: !!value.properties?.type,
+        valueType: value.properties?.value?.type,
+        typeEnum: value.properties?.type?.enum,
+        uiSchemaKeys: uiSchema ? Object.keys(uiSchema) : 'no uiSchema'
+      });
+      const meta = {
+        title: value.title || '',
+        description: value.description || '',
+        type: value.type || 'object',
+        position: 0
+      };
+      if (isComposite) {
+        meta['x-composite-type'] = 'compositeNumberSelect';
+      }
+      // Preserve custom metadata properties for configuration and secret elements
+      if ('fieldMeta' in value) meta['fieldMeta'] = value['fieldMeta'];
+      if ('isSecretElement' in value) meta.isSecretElement = value.isSecretElement;
+      if ('writeOnly' in value) meta.writeOnly = value.writeOnly;
+      if ('databaseField' in value) meta.databaseField = value.databaseField;
+      if ('columnsPerRow' in value) meta.columnsPerRow = value.columnsPerRow;
+      // Preserve schema element flags for elements from configuration/policy schemas
+      if ('isSchemaElement' in value) meta.isSchemaElement = value.isSchemaElement;
+      if ('sourceSchemaId' in value) meta.sourceSchemaId = value.sourceSchemaId;
+      // CRITICAL: Preserve secret/environment variable properties
+      if ('isEnvironmentVariable' in value) meta.isEnvironmentVariable = value.isEnvironmentVariable;
+      if ('secretType' in value) meta.secretType = value.secretType;
+      if ('vaultKeyName' in value) meta.vaultKeyName = value.vaultKeyName;
+      if ('x-env' in value) meta['x-env'] = value['x-env'];
+      result[`${newKey}.meta`] = meta;
+      if (value.required) {
+        result[`${newKey}.required`] = value.required;
+      }
+      // Recursively process nested properties with correct uiSchema context
+      const nestedUiSchema = uiSchema?.[key];
+      const nestedFlattened = flattenSchemaWithUiContext(value.properties, nestedUiSchema, newKey);
+      console.log(`[FlattenSchema:Fallback] Recursive result for ${newKey}:`, {
+        inputKeys: Object.keys(value.properties || {}),
+        outputKeys: Object.keys(nestedFlattened),
+        sampleOutputKeys: Object.keys(nestedFlattened).slice(0, 5)
+      });
+      Object.assign(result, nestedFlattened);
+    } else if (value && typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length > 0) {
+      if (value.type || value.title || value.$ref) {
+        result[newKey] = value;
+      } else {
+        // Recursively process object without explicit type
+        const nestedUiSchema = uiSchema?.[key];
+        Object.assign(result, flattenSchemaWithUiContext(value, nestedUiSchema, newKey));
+      }
+    } else {
+      result[newKey] = value;
+    }
+  });
+  return result;
+};
+const flattenUiSchema = (uiSchema, prefix = '') => {
+  const result = {};
+  if (!uiSchema || typeof uiSchema !== 'object' || Array.isArray(uiSchema)) {
+    return result;
+  }
+  Object.keys(uiSchema).forEach(key => {
+    const value = uiSchema[key];
+    const newKey = prefix ? `${prefix}.${key}` : key;
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+      // Separate UI properties from nested fields
+      const uiProperties = {};
+      const nestedFields = {};
+      Object.keys(value).forEach(subKey => {
+        if (subKey.startsWith('ui:')) {
+          uiProperties[subKey] = value[subKey];
+        } else {
+          nestedFields[subKey] = value[subKey];
+        }
+      });
+      // If this object has UI properties, store them
+      if (Object.keys(uiProperties).length > 0) {
+        result[newKey] = uiProperties;
+      }
+      // If this object has nested fields, recurse into them
+      if (Object.keys(nestedFields).length > 0) {
+        const nestedResults = flattenUiSchema(nestedFields, newKey);
+        Object.assign(result, nestedResults);
+      }
+    } else {
+      // Handle primitive values (though rare in UI schema)
+      result[newKey] = value;
+    }
+  });
+  return result;
+};
+const flattenSchemas = schemas => {
+  const result = {};
+  // Flatten form schema if provided, passing UI schema for composite element detection
+  if (schemas.formSchema) {
+    const flattened = flattenSchemaWithUiContext(schemas.formSchema, schemas.uiSchema);
+    // Safeguard: Remove any top-level schema keys that should not be in flattened output
+    // The flattened result should only contain dot-notation keys and 'required' array
+    if ('type' in flattened && flattened.type === 'object') {
+      delete flattened.type;
+    }
+    if ('title' in flattened && typeof flattened.title === 'string') {
+      delete flattened.title;
+    }
+    result.formSchema = flattened;
+  }
+  // Flatten UI schema if provided
+  if (schemas.uiSchema) {
+    result.uiSchema = flattenUiSchema(schemas.uiSchema);
+  }
+  return result;
+};
+const parseSampleNodes = (sampleNodes, fallbackSchemaId, fallbackType) => {
+  const groups = [];
+  let pendingNodes = [];
+  let currentGroup = null;
+  for (const node of sampleNodes) {
+    if (node?.type === FORM_METADATA_NODE_TYPE) {
+      if (currentGroup) {
+        groups.push(currentGroup);
+      }
+      const nodes = [node];
+      if (pendingNodes.length > 0) {
+        nodes.push(...pendingNodes);
+        pendingNodes = [];
+      }
+      currentGroup = {
+        metadataNode: node,
+        nodes
+      };
+    } else if (currentGroup) {
+      currentGroup.nodes.push(node);
+    } else {
+      pendingNodes.push(node);
+    }
+  }
+  if (currentGroup) {
+    groups.push(currentGroup);
+  } else if (pendingNodes.length > 0) {
+    groups.push({
+      nodes: pendingNodes
+    });
+  }
+  const explicitMainIdx = groups.findIndex(g => g.metadataNode?.type === FORM_METADATA_NODE_TYPE && !g.metadataNode?.properties?.schemaId);
+  const mainIdx = explicitMainIdx >= 0 ? explicitMainIdx : 0;
+  const mainGroup = groups[mainIdx];
+  const mainMetadataNode = mainGroup?.metadataNode || null;
+  const mainNodes = (mainGroup?.nodes || sampleNodes).filter(n => n.type !== FORM_METADATA_NODE_TYPE);
+  const additionalSchemas = [];
+  groups.forEach((group, idx) => {
+    if (idx === mainIdx) return;
+    if (!group?.nodes || group.nodes.length === 0) return;
+    const meta = group.metadataNode?.properties || {};
+    const groupSchemaId = meta.schemaId || fallbackSchemaId;
+    const groupType = meta.type || (isContributionSchemaId(groupSchemaId) ? FormType.CONTRIBUTION : fallbackType);
+    const groupFormId = isContributionSchemaId(groupSchemaId) ? '' : meta.id || '';
+    additionalSchemas.push({
+      schemaId: groupSchemaId,
+      type: groupType,
+      formId: groupFormId,
+      configurationNodes: group.nodes
+    });
+  });
+  return {
+    mainNodes,
+    mainMetadataNode,
+    additionalSchemas
+  };
+};export{DatabaseType,FORM_METADATA_NODE_TYPE,FormType,SCHEMA_ID_OPTIONS,flattenSchemaWithUiContext,flattenSchemas,flattenUiSchema,isContributionSchemaId,parseSampleNodes};//# sourceMappingURL=schemaHelpers.js.map

package/lib/utils/schemaHelpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemaHelpers.js","sources":["../../src/utils/schemaHelpers.ts"],"sourcesContent":[null],"names":[],"mappings":"0CAGW,MAAA,uBAAO,GAAA;AACR,IAAA;WACN,QAAW,EAAA;AACX,EAAA,QAAK,CAAE,cAAS,CAAA,GAAA,cAAA;AAChB,EAAA,QAAA,CAAA,kBAAqB,CAAA,GAAA,iBAAA;UACrB,CAAA,YAAmB,CAAA,GAAA,YAAA;;WAAe,aAAa,GAAA,EAAA,CAAA,CAAA;AAAI,IAAA;WAC7C,YAAQ,EAAA;cAAO,CAAE,YAAO,CAAA,GAAA,YAAA;cAAM,CAAE,OAAM,CAAA,GAAA,OAAA;AAAE,EAAA,YAAE,CAAA,SAAA,CAAA,GAAA,SAAA;eACrC,KAAG,YAAQ,GAAA,EAAA,CAAA,CAAA;AACtB,MAAA,iBAA0B,GAAE;WACtB,CAAE,YAAU,GAAA,CAAA;IAClB,KAAA,EAAO,oBAAS,CAAA,QAAA;IAChB,KAAA,EAAO;KACP;IACA,KAAK,EAAE,oBAAO,CAAA,UAAA;IACd,KAAA,EAAA;AACA,GAAA,EAAA;SACI,EAAA,oBAAqB,CAAA,aAAA;SACvB,EAAA;AACL,GAAA,EAAA;AAED,IAAA,2BAA2B,CAAA,MAAA;IACvB,KAAK,EAAE;KACP;IACA,KAAA,EAAA,oBAA0B,CAAE,QAAK;AACpC,IAAA,KAAA,EAAA;AAED,GAAA;AACI;;SAEI,EAAA,UAAQ;SACR,EAAA;AACA,GAAA,EAAA;SACA,EAAA,OAAQ;SACR,EAAA;KACH;IACD,KAAA,EAAA,oBAA0B,CAAA,gBAAK;IAC/B,KAAA,EAAA;AACH,GAAA,CAAA;AAOD,EAAA,CAAA,QAAM,CAAM,mBAAkB,CAAA;IAC1B,KAAA,EAAA,qBAAiB;AACjB,IAAA,KAAA,EAAA,oBAAwB;IACxB,YAAA,EAAA,YAAyB,CAAA;;SAErB,EAAA,gBAAa;SACb,EAAA,eAAe;gBACf,EAAA,YAAoB,CAAG;AAC1B,GAAA,EAAA;IACH,KAAA,EAAA,kBAAA;AAEF,IAAA,KAAA,EAAA,iBAAa;AAEb,IAAA,YAAA,EAAA,YAAoB,CAAA;AAChB,GAAA,CAAA;AACA,EAAA,CAAA,QAAA,CAAA,UAAgB,GAAA,CAAA;AAChB,IAAA,KAAA,EAAA,cAAU;AAEb,IAAA,KAAA,EAAA;AAED,GAAA,EAAA;AACI,IAAA,KAAA,EAAA,mBAAyB;AACzB,IAAA,KAAK,EAAA;AACL,GAAA;AACH;AAED;;;;;;;;;;;;;;CAsBC;AAED,MAAA,0BAAa,GAAA,CAAsB,gBAAc,EAAA,MAAS,OAGzD,UAAC,GAAA,EAAA,KAAA;AAgBF,EAAA,MAAA,MAAA,GAAO,EAAA;AAkVP;AA2CA,EAAA,OAAA,CAAA,GAAA,CAAA,CAAO,mCAAiC,CAAA,EAAA;AA2BxC,IAAA,MAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}