@adminide-stack/marketplace-module-server 12.0.4-alpha.95 → 13.0.1-alpha.0

package/lib/graphql/resolvers/index.d.ts

@@ -1,2 +1,248 @@
-export declare const resolvers: ((pubsub: import("graphql-subscriptions").PubSub, logger?: import("@cdm-logger/core/lib/interface").ILogger) => import("common").IResolvers)[];
+export declare const resolvers: (((pubsub: import("graphql-subscriptions").PubSub, logger?: import("@cdm-logger/core/lib/interface").ILogger) => import("common").IResolvers) | (() => {
+    Query: {
+        instances: (root: any, args: any, ctx: any) => Promise<any>;
+        gallery: (root: any, { query }: {
+            query?: {};
+        }, ctx: any) => Promise<any>;
+        galleryExtension: (root: any, { extensionSlug }: {
+            extensionSlug: any;
+        }, ctx: any) => Promise<any>;
+    };
+    Mutation: {
+        startExtensionHost: (root: any, args: any, ctx: any) => Promise<boolean>;
+    };
+}) | (() => {
+    Query: {
+        marketplaceFormTemplates: (_: unknown, { input }: {
+            input?: {
+                search?: string;
+                category?: string;
+                publisherId?: string;
+                installed?: boolean;
+                limit?: number;
+                offset?: number;
+            };
+        }, context: {
+            user?: {
+                id: string;
+                name: string;
+                email: string;
+            };
+        }) => Promise<{
+            nodes: {
+                id: string;
+                name: string;
+                description: string;
+                category: string;
+                version: string;
+                author: string;
+                publisherId: string;
+                tags: string[];
+                schema: string;
+                uiSchema: string;
+                downloads: number;
+                rating: number;
+                reviewCount: number;
+                createdAt: Date;
+                updatedAt: Date;
+                installed: boolean;
+                preview: any;
+                publisher: {
+                    id: string;
+                    name: string;
+                    email: string;
+                };
+            }[];
+            totalCount: number;
+            pageInfo: {
+                hasNextPage: boolean;
+                hasPreviousPage: boolean;
+                startCursor: string;
+                endCursor: string;
+            };
+        }>;
+        marketplaceFormTemplate: (_: unknown, { id }: {
+            id: string;
+        }, context: {
+            user?: {
+                id: string;
+                name: string;
+                email: string;
+            };
+        }) => Promise<{
+            id: string;
+            name: string;
+            description: string;
+            category: string;
+            version: string;
+            author: string;
+            publisherId: string;
+            tags: string[];
+            schema: string;
+            uiSchema: string;
+            downloads: number;
+            rating: number;
+            reviewCount: number;
+            createdAt: Date;
+            updatedAt: Date;
+            installed: boolean;
+            preview: any;
+            publisher: {
+                id: string;
+                name: string;
+                email: string;
+            };
+        }>;
+        marketplaceInstalledFormTemplates: () => Promise<{
+            id: string;
+            name: string;
+            description: string;
+            category: string;
+            version: string;
+            author: string;
+            publisherId: string;
+            tags: string[];
+            schema: string;
+            uiSchema: string;
+            downloads: number;
+            rating: number;
+            reviewCount: number;
+            createdAt: Date;
+            updatedAt: Date;
+            installed: boolean;
+            preview: any;
+            publisher: {
+                id: string;
+                name: string;
+                email: string;
+            };
+        }[]>;
+        marketplaceMyFormTemplates: () => Promise<any[]>;
+        marketplacePopularFormTemplates: () => Promise<any[]>;
+        marketplaceRecentFormTemplates: () => Promise<any[]>;
+    };
+    Mutation: {
+        marketplacePublishFormTemplate: (_: unknown, { input }: {
+            input: unknown;
+        }, context: {
+            user?: {
+                id: string;
+                name: string;
+                email: string;
+            };
+        }) => Promise<{
+            success: boolean;
+            message: string;
+            formTemplate: {
+                id: string;
+                name: string;
+                description: string;
+                category: string;
+                version: string;
+                author: string;
+                publisherId: string;
+                tags: string[];
+                schema: string;
+                uiSchema: string;
+                downloads: number;
+                rating: number;
+                reviewCount: number;
+                createdAt: Date;
+                updatedAt: Date;
+                installed: boolean;
+                preview: any;
+                publisher: {
+                    id: string;
+                    name: string;
+                    email: string;
+                };
+            };
+        }>;
+        marketplaceInstallFormTemplate: (_: unknown, { input }: {
+            input: {
+                id: string;
+            };
+        }, context: {
+            user?: {
+                id: string;
+                name: string;
+                email: string;
+            };
+        }) => Promise<{
+            success: boolean;
+            message: string;
+            formTemplate: {
+                id: string;
+                name: string;
+                description: string;
+                category: string;
+                version: string;
+                author: string;
+                publisherId: string;
+                tags: string[];
+                schema: string;
+                uiSchema: string;
+                downloads: number;
+                rating: number;
+                reviewCount: number;
+                createdAt: Date;
+                updatedAt: Date;
+                installed: boolean;
+                preview: any;
+                publisher: {
+                    id: string;
+                    name: string;
+                    email: string;
+                };
+            };
+        }>;
+        marketplaceUninstallFormTemplate: () => Promise<{
+            success: boolean;
+            message: string;
+        }>;
+        marketplaceUpdateFormTemplate: () => Promise<{
+            success: boolean;
+            message: string;
+            formTemplate: {
+                id: string;
+                name: string;
+                description: string;
+                category: string;
+                version: string;
+                author: string;
+                publisherId: string;
+                tags: string[];
+                schema: string;
+                uiSchema: string;
+                downloads: number;
+                rating: number;
+                reviewCount: number;
+                createdAt: Date;
+                updatedAt: Date;
+                installed: boolean;
+                preview: any;
+                publisher: {
+                    id: string;
+                    name: string;
+                    email: string;
+                };
+            };
+        }>;
+        marketplaceDeleteFormTemplate: () => Promise<{
+            success: boolean;
+            message: string;
+        }>;
+        marketplaceRateFormTemplate: () => Promise<{
+            success: boolean;
+            message: string;
+        }>;
+    };
+    Subscription: {
+        marketplaceFormTemplateEvents: {
+            subscribe: (_: unknown, { publisherId }: {
+                publisherId?: string;
+            }) => AsyncIterator<unknown, any, any>;
+        };
+    };
+}))[];
 //# sourceMappingURL=index.d.ts.map

package/lib/graphql/resolvers/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/graphql/resolvers/index.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,SAAS,gJAAiD,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/graphql/resolvers/index.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;iBASujC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAAsuJ,CAAC;;;;KADpzL,CAAC"}

package/lib/graphql/resolvers/index.js

@@ -1 +1 @@
-import {resolver}from'./registry-extension-resolver.js';import {resolver as resolver$1}from'./installed-extension-resolver.js';const resolvers = [resolver, resolver$1];export{resolvers};//# sourceMappingURL=index.js.map
+import {resolver}from'./registry-extension-resolver.js';import {resolver as resolver$1}from'./installed-extension-resolver.js';import {resolver as resolver$2}from'./gallery-resolver.js';import {publisherResolver}from'./publisher-resolver.js';import {marketplaceFormResolver}from'./marketplace-form-resolver.js';import {publisherAnalyticsResolver}from'./publisher-analytics-resolver.js';import {formTemplateResolvers}from'./form-templates-resolver.js';const resolvers = [resolver, resolver$1, resolver$2, publisherResolver, marketplaceFormResolver, publisherAnalyticsResolver, formTemplateResolvers];export{resolvers};//# sourceMappingURL=index.js.map

package/lib/graphql/resolvers/installed-extension-resolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"installed-extension-resolver.d.ts","sourceRoot":"","sources":["../../../src/graphql/resolvers/installed-extension-resolver.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAuB,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhE,eAAO,MAAM,QAAQ,GAAI,QAAQ,MAAM,EAAE,SAAS,SAAS,CAAC,OAAO,KAAG,UAgOpE,CAAC"}
+{"version":3,"file":"installed-extension-resolver.d.ts","sourceRoot":"","sources":["../../../src/graphql/resolvers/installed-extension-resolver.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAuB,UAAU,EAA0C,MAAM,eAAe,CAAC;AAExG,eAAO,MAAM,QAAQ,GAAI,QAAQ,MAAM,EAAE,SAAS,SAAS,CAAC,OAAO,KAAG,UAsXpE,CAAC"}

package/lib/graphql/resolvers/installed-extension-resolver.js

@@ -1,27 +1,66 @@
 const resolver = (pubsub, logger) => ({
   InstalledExtension: {
-    extension: (root, args, ctx) => {
-      // Check if extension exists and is not null/undefined before calling dataloader
-      if (!root.extension || root.extension === null || root.extension === undefined) {
+    organization: (root, args, context, info) => {
+      const {
+        organizationDataLoader
+      } = context;
+      // The organization field from the model contains an ObjectId reference
+      if (!root.organization) {
+        return null;
+      }
+      // Convert ObjectId to string for the dataloader
+      const organizationId = String(root.organization);
+      return organizationDataLoader.load(organizationId);
+    },
+    extension: (root, args, {
+      registryExtensionDataLoader
+    }) => {
+      // The extension field contains an ObjectId reference
+      if (!root.extension) {
+        return null;
+      }
+      // Convert ObjectId to string for the dataloader
+      const extensionId = String(root.extension);
+      return registryExtensionDataLoader.load(extensionId);
+    },
+    sourceDocument: async (root, _args, ctx) => {
+      if (!root.sourceCollection || !root.sourceDocumentId) {
+        return null;
+      }
+      try {
+        return await ctx.extensionSourceDocumentDataLoader.load(root.sourceCollection, root.sourceDocumentId);
+      } catch (error) {
+        if (logger) {
+          logger.error('Error loading source document for InstalledExtension:', error);
+        }
         return null;
       }
-      const extensionSlug = String(root.extension); // Convert ObjectId to string
-      return ctx.registryExtensionDataLoader.load(extensionSlug);
     }
   },
   Query: {
     /**
-     * Get all installed extensions for the current tenant
+     * Get all installed extensions for the current user/organization
      */
-    async installedExtensions(root, args, {
+    async installedExtensions(root, {
+      enabled,
+      orgName
+    }, {
       userContext,
-      installedExtensionService
+      installedExtensionService,
+      slugService
     }) {
-      const query = {
-        tenantId: userContext.tenantId
-      };
-      if (args.enabled !== undefined) {
-        query['settings.effectiveEnabled'] = args.enabled;
+      const query = {};
+      // Map orgName to orgId using slugService for filtering
+      if (orgName) {
+        const orgId = await slugService.resolveOrganizationSlug(orgName);
+        if (orgId) {
+          query.orgId = orgId;
+        }
+      } else {
+        query.orgId = userContext.organization?.id;
+      }
+      if (enabled !== undefined) {
+        query['settings.effectiveEnabled'] = enabled;
       }
       const results = await installedExtensionService.getInstalledExtensions(query);
       return results;
@@ -31,27 +70,44 @@ const resolver = (pubsub, logger) => ({
      */
     async installedExtension(root, args, {
       userContext,
-      installedExtensionService
+      installedExtensionService,
+      slugService
     }) {
-      return installedExtensionService.getInstalledExtension(userContext.tenantId, args.extensionSlug);
+      let orgId;
+      if (args.orgName) {
+        orgId = await slugService.resolveOrganizationSlug(args.orgName);
+      }
+      const result = await installedExtensionService.getInstalledExtension(orgId, args.extensionSlug);
+      return result;
     },
     /**
      * Get installed extensions that need attention (updates, deprecated, etc.)
      */
     async extensionsNeedingAttention(root, args, {
       userContext,
-      installedExtensionService
+      installedExtensionService,
+      slugService
     }) {
-      return installedExtensionService.getExtensionsNeedingAttention(userContext.tenantId);
+      let orgId;
+      if (args.orgName) {
+        orgId = await slugService.resolveOrganizationSlug(args.orgName);
+      }
+      const result = await installedExtensionService.getExtensionsNeedingAttention(orgId);
+      return result;
     },
     /**
      * Check for available updates
      */
     async extensionUpdates(root, args, {
       userContext,
-      installedExtensionService
+      installedExtensionService,
+      slugService
     }) {
-      return installedExtensionService.checkForUpdates(userContext.tenantId, args.extensionSlug);
+      let orgId;
+      if (args.orgName) {
+        orgId = await slugService.resolveOrganizationSlug(args.orgName);
+      }
+      return installedExtensionService.checkForUpdates(orgId, args.extensionSlug);
     }
   },
   Mutation: {
@@ -61,15 +117,35 @@ const resolver = (pubsub, logger) => ({
     async installExtension(root, args, {
       userContext,
       installedExtensionService,
-      registryExtensionService
+      registryExtensionService,
+      slugService
     }) {
       try {
-        const installedExtension = await installedExtensionService.installExtension({
+        // Map orgName to orgId using slugService if provided
+        let orgId;
+        if (args.input.orgName) {
+          orgId = await slugService.resolveOrganizationSlug(args.input.orgName);
+          if (!orgId) {
+            return {
+              success: false,
+              extension: null,
+              message: `Organization '${args.input.orgName}' not found`
+            };
+          }
+        }
+        const installData = {
           ...args.input,
-          tenantId: userContext.tenantId,
+          accountId: userContext.accountId,
+          orgId,
+          // This will be the mapped orgId from orgName
+          version: args.input.version,
+          // Ensure version is passed through
           installedVersion: args.input.version,
           installedBy: userContext.accountId
-        });
+        };
+        console.log('GraphQL Resolver - Install Data:', JSON.stringify(installData, null, 2));
+        console.log('Original args.input:', JSON.stringify(args.input, null, 2));
+        const installedExtension = await installedExtensionService.installExtension(installData, userContext.tenantId);
         return {
           success: true,
           extension: installedExtension,
@@ -89,10 +165,15 @@ const resolver = (pubsub, logger) => ({
     async uninstallExtension(root, args, {
       userContext,
       installedExtensionService,
-      registryExtensionService
+      registryExtensionService,
+      slugService
     }) {
       try {
-        const success = await installedExtensionService.uninstallExtension(userContext.tenantId, args.extensionSlug, userContext.accountId);
+        let orgId;
+        if (args.orgName) {
+          orgId = await slugService.resolveOrganizationSlug(args.orgName);
+        }
+        const success = await installedExtensionService.uninstallExtension(orgId, args.extensionSlug, userContext.accountId, userContext.tenantId);
         if (success) {
           // Update the registry extension as uninstalled
           await registryExtensionService.updateExtension(args.extensionSlug, {
@@ -115,9 +196,14 @@ const resolver = (pubsub, logger) => ({
      */
     async toggleExtension(root, args, {
       userContext,
-      installedExtensionService
+      installedExtensionService,
+      slugService
     }) {
-      const extension = await installedExtensionService.toggleExtension(userContext.tenantId, args.extensionSlug, args.enabled, userContext.accountId);
+      let orgId;
+      if (args.orgName) {
+        orgId = await slugService.resolveOrganizationSlug(args.orgName);
+      }
+      const extension = await installedExtensionService.toggleExtension(orgId, args.extensionSlug, args.enabled, userContext.accountId, userContext.tenantId);
       return {
         success: true,
         extension: extension,
@@ -129,9 +215,14 @@ const resolver = (pubsub, logger) => ({
      */
     async updateExtensionSettings(root, args, {
       userContext,
-      installedExtensionService
+      installedExtensionService,
+      slugService
     }) {
-      const extension = await installedExtensionService.updateExtensionSettings(userContext.tenantId, args.extensionSlug, args.settings, userContext.accountId);
+      let orgId;
+      if (args.orgName) {
+        orgId = await slugService.resolveOrganizationSlug(args.orgName);
+      }
+      const extension = await installedExtensionService.updateExtensionSettings(orgId, args.extensionSlug, args.settings, userContext.accountId, userContext.tenantId);
       return {
         success: true,
         extension: extension,
@@ -143,9 +234,14 @@ const resolver = (pubsub, logger) => ({
      */
     async updateExtensionVersion(root, args, {
       userContext,
-      installedExtensionService
+      installedExtensionService,
+      slugService
     }) {
-      const extension = await installedExtensionService.updateExtensionVersion(userContext.tenantId, args.extensionSlug, args.version, userContext.accountId);
+      let orgId;
+      if (args.orgName) {
+        orgId = await slugService.resolveOrganizationSlug(args.orgName);
+      }
+      const extension = await installedExtensionService.updateExtensionVersion(orgId, args.extensionSlug, args.version, userContext.accountId, userContext.tenantId);
       return {
         success: true,
         extension: extension,
@@ -157,9 +253,14 @@ const resolver = (pubsub, logger) => ({
      */
     async syncExtensionsWithRegistry(root, args, {
       userContext,
-      installedExtensionService
+      installedExtensionService,
+      slugService
     }) {
-      await installedExtensionService.syncWithRegistry(userContext.tenantId);
+      let orgId;
+      if (args.orgName) {
+        orgId = await slugService.resolveOrganizationSlug(args.orgName);
+      }
+      await installedExtensionService.syncWithRegistry(orgId, userContext.tenantId);
       return {
         success: true,
         message: 'Extensions synced with registry successfully'
@@ -170,14 +271,39 @@ const resolver = (pubsub, logger) => ({
      */
     async cleanupExtensions(root, args, {
       userContext,
-      installedExtensionService
+      installedExtensionService,
+      slugService
     }) {
-      const result = await installedExtensionService.cleanupExtensions(userContext.tenantId, args.dryRun || false);
+      let orgId;
+      if (args.orgName) {
+        orgId = await slugService.resolveOrganizationSlug(args.orgName);
+      }
+      const result = await installedExtensionService.cleanupExtensions(orgId, userContext.tenantId, args.dryRun || false);
       return {
         success: true,
         result,
         message: args.dryRun ? 'Cleanup preview completed' : `Cleanup completed: ${result.removed.length} removed, ${result.deprecated.length} deprecated`
       };
+    },
+    /**
+     * Clean up orphaned extensions that exist in installed_extensions but not in system_extension registry
+     */
+    async cleanupOrphanedExtensions(root, args, {
+      userContext,
+      installedExtensionService,
+      slugService
+    }) {
+      let orgId;
+      if (args.orgName) {
+        orgId = await slugService.resolveOrganizationSlug(args.orgName);
+      }
+      const result = await installedExtensionService.cleanupOrphanedExtensions(orgId, userContext.tenantId, args.dryRun || false);
+      return {
+        success: true,
+        removed: result.removed,
+        warnings: result.warnings,
+        message: args.dryRun ? `Preview: ${result.removed.length} orphaned extension(s) would be removed` : `Cleanup completed: ${result.removed.length} orphaned extension(s) removed`
+      };
     }
   }
 });export{resolver};//# sourceMappingURL=installed-extension-resolver.js.map

package/lib/graphql/resolvers/installed-extension-resolver.js.map

@@ -1 +1 @@
-{"version":3,"file":"installed-extension-resolver.js","sources":["../../../src/graphql/resolvers/installed-extension-resolver.ts"],"sourcesContent":[null],"names":[],"mappings":"AAES,MAAA,QAAQ;AACjB,EAAA,kBAAoB,EAAA;AACpB,IAAA,SAA8B,EAAA,CAAA,IAAY,EAAA,IAAA;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"installed-extension-resolver.js","sources":["../../../src/graphql/resolvers/installed-extension-resolver.ts"],"sourcesContent":[null],"names":[],"mappings":"AAES,MAAA,QAAQ;AACjB,EAAA,kBAAoB,EAAA;AACpB,IAAA,YAA8B,EAAA,CAAU,IAA0C,EAAA,mBAAsB,KAAA;AAExG,MAAA,MAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/graphql/resolvers/marketplace-form-resolver.d.ts

@@ -0,0 +1,13 @@
+import { PubSub } from 'graphql-subscriptions';
+import { CdmLogger } from '@cdm-logger/core';
+import { IResolvers } from 'common/server';
+/**
+ * Marketplace Form Submission Resolver
+ *
+ * Handles enhanced marketplace features for extension management:
+ * - Form submission processing
+ * - Extension validation
+ * - Enhanced extension publishing
+ */
+export declare const marketplaceFormResolver: (pubsub: PubSub, logger?: CdmLogger.ILogger) => IResolvers;
+//# sourceMappingURL=marketplace-form-resolver.d.ts.map

package/lib/graphql/resolvers/marketplace-form-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"marketplace-form-resolver.d.ts","sourceRoot":"","sources":["../../../src/graphql/resolvers/marketplace-form-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAsB,MAAM,eAAe,CAAC;AAE/D;;;;;;;GAOG;AACH,eAAO,MAAM,uBAAuB,GAAI,QAAQ,MAAM,EAAE,SAAS,SAAS,CAAC,OAAO,KAAG,UA+HnF,CAAC"}

package/lib/graphql/resolvers/marketplace-form-resolver.js

@@ -0,0 +1,90 @@
+/**
+ * Marketplace Form Submission Resolver
+ *
+ * Handles enhanced marketplace features for extension management:
+ * - Form submission processing
+ * - Extension validation
+ * - Enhanced extension publishing
+ */
+const marketplaceFormResolver = (pubsub, logger) => ({
+  Mutation: {
+    /**
+     * Process marketplace form submissions
+     * Supports different submission types: extension-publish, extension-validate, extension-update
+     */
+    async marketplaceFormSubmission(root, args, ctx) {
+      if (logger) {
+        logger.debug('marketplaceFormSubmission args [%j]', args);
+      }
+      const result = await ctx.registryExtensionService.formSubmission({
+        extensionSlug: args.input.extensionSlug,
+        formData: args.input.formData,
+        submissionType: args.input.submissionType,
+        metadata: args.input.metadata
+      });
+      return {
+        success: result.success,
+        message: result.message,
+        errors: result.errors || [],
+        submissionId: result.submissionId,
+        data: result.data
+      };
+    },
+    /**
+     * Validate extension before publishing
+     * Checks manifest structure, version format, and extension conflicts
+     */
+    async marketplaceValidateExtension(root, args, ctx) {
+      if (logger) {
+        logger.debug('marketplaceValidateExtension args [%j]', args);
+      }
+      const result = await ctx.registryExtensionService.validateExtension({
+        manifest: args.input.manifest,
+        bundle: args.input.bundle,
+        sourceMap: args.input.sourceMap,
+        extensionSlug: args.input.extensionSlug,
+        version: args.input.version
+      });
+      return {
+        isValid: result.isValid,
+        errors: result.errors.map(e => ({
+          field: e.field,
+          message: e.message,
+          code: e.code
+        })),
+        warnings: result.warnings.map(w => ({
+          field: w.field,
+          message: w.message,
+          code: w.code
+        })),
+        metadata: result.metadata
+      };
+    },
+    /**
+     * Enhanced extension publishing with validation and pre-release support
+     * Includes force publishing and comprehensive error handling
+     */
+    async marketplacePublishExtension(root, args, ctx) {
+      if (logger) {
+        logger.debug('marketplacePublishExtension args [%j]', args);
+      }
+      const result = await ctx.registryExtensionService.publishExtensionEnhanced({
+        extensionSlug: args.input.extensionSlug,
+        manifest: args.input.manifest,
+        bundle: args.input.bundle,
+        sourceMap: args.input.sourceMap,
+        version: args.input.version,
+        releaseNotes: args.input.releaseNotes,
+        force: args.input.force,
+        preRelease: args.input.preRelease
+      });
+      return {
+        success: result.success,
+        extension: result.extension ? result.extension : null,
+        message: result.message,
+        errors: result.errors || [],
+        releaseId: result.releaseId
+      };
+    }
+  }
+});export{marketplaceFormResolver};//# sourceMappingURL=marketplace-form-resolver.js.map

package/lib/graphql/resolvers/marketplace-form-resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"marketplace-form-resolver.js","sources":["../../../src/graphql/resolvers/marketplace-form-resolver.ts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;AACA;AACA;AAEA;;;;;;;AAOG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}