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

package/lib/graphql/resolvers/publisher-analytics-resolver.d.ts

@@ -0,0 +1,14 @@
+import { PubSub } from 'graphql-subscriptions';
+import { CdmLogger } from '@cdm-logger/core';
+import { IResolvers } from 'common/server';
+/**
+ * Publisher Analytics Resolver
+ *
+ * Handles comprehensive analytics and insights for extension publishers:
+ * - Publisher analytics and metrics
+ * - Revenue analytics
+ * - Analytics event tracking
+ * - Real-time analytics subscriptions
+ */
+export declare const publisherAnalyticsResolver: (pubsub: PubSub, logger?: CdmLogger.ILogger) => IResolvers;
+//# sourceMappingURL=publisher-analytics-resolver.d.ts.map

package/lib/graphql/resolvers/publisher-analytics-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publisher-analytics-resolver.d.ts","sourceRoot":"","sources":["../../../src/graphql/resolvers/publisher-analytics-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,EAAE,MAAM,eAAe,CAAC;AAE3C;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B,GAAI,QAAQ,MAAM,EAAE,SAAS,SAAS,CAAC,OAAO,KAAG,UAwQ3E,CAAC"}

package/lib/graphql/resolvers/publisher-analytics-resolver.js

@@ -0,0 +1,221 @@
+/**
+ * Publisher Analytics Resolver
+ *
+ * Handles comprehensive analytics and insights for extension publishers:
+ * - Publisher analytics and metrics
+ * - Revenue analytics
+ * - Analytics event tracking
+ * - Real-time analytics subscriptions
+ */
+const publisherAnalyticsResolver = (pubsub, logger) => ({
+  Query: {
+    /**
+     * Get comprehensive analytics for a publisher
+     */
+    publisherAnalytics: async (root, args,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    ctx) => {
+      if (logger) {
+        logger.debug('publisherAnalytics args [%j]', args);
+      }
+      // Mock analytics data for now - in real implementation, this would use the analytics service
+      const mockAnalytics = {
+        publisherId: args.input.publisherId,
+        totalExtensions: Math.floor(Math.random() * 50) + 5,
+        totalDownloads: Math.floor(Math.random() * 100000) + 10000,
+        totalInstallations: Math.floor(Math.random() * 50000) + 5000,
+        averageRating: 4.2 + Math.random() * 0.8,
+        period: args.input.period,
+        extensions: [{
+          extensionSlug: 'sample-extension-1',
+          name: 'Sample Extension 1',
+          version: '1.0.0',
+          downloads: Math.floor(Math.random() * 10000),
+          installations: Math.floor(Math.random() * 5000),
+          rating: 4.0 + Math.random() * 1.0,
+          reviewCount: Math.floor(Math.random() * 100),
+          revenue: args.input.includeRevenue ? Math.random() * 1000 : null,
+          lastUpdated: new Date().toISOString(),
+          versionMetrics: [{
+            version: '1.0.0',
+            downloads: Math.floor(Math.random() * 1000),
+            installations: Math.floor(Math.random() * 500),
+            releasedAt: new Date().toISOString(),
+            adoptionRate: Math.random() * 100
+          }]
+        }],
+        downloadTrend: Array.from({
+          length: 30
+        }, (_, i) => ({
+          timestamp: new Date(Date.now() - i * 24 * 60 * 60 * 1000).toISOString(),
+          value: Math.floor(Math.random() * 1000),
+          secondaryValue: Math.floor(Math.random() * 100)
+        })),
+        installationTrend: Array.from({
+          length: 30
+        }, (_, i) => ({
+          timestamp: new Date(Date.now() - i * 24 * 60 * 60 * 1000).toISOString(),
+          value: Math.floor(Math.random() * 500),
+          secondaryValue: Math.floor(Math.random() * 50)
+        })),
+        popularRegions: args.input.includeRegions ? [{
+          region: 'US',
+          regionName: 'United States',
+          downloads: Math.floor(Math.random() * 10000),
+          installations: Math.floor(Math.random() * 5000),
+          percentage: Math.random() * 20
+        }, {
+          region: 'UK',
+          regionName: 'United Kingdom',
+          downloads: Math.floor(Math.random() * 8000),
+          installations: Math.floor(Math.random() * 4000),
+          percentage: Math.random() * 15
+        }] : []
+      };
+      return mockAnalytics;
+    },
+    /**
+     * Get revenue analytics for a publisher
+     */
+    publisherRevenueAnalytics: async (root, args,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    ctx) => {
+      if (logger) {
+        logger.debug('publisherRevenueAnalytics args [%j]', args);
+      }
+      const mockRevenue = {
+        publisherId: args.input.publisherId,
+        totalRevenue: Math.random() * 10000,
+        currency: args.input.currency || 'USD',
+        extensionRevenue: [{
+          extensionSlug: 'sample-extension-1',
+          name: 'Sample Extension 1',
+          revenue: Math.random() * 500,
+          paidInstallations: Math.floor(Math.random() * 100),
+          arpu: Math.random() * 10
+        }],
+        revenueTrend: Array.from({
+          length: 30
+        }, (_, i) => ({
+          timestamp: new Date(Date.now() - i * 24 * 60 * 60 * 1000).toISOString(),
+          revenue: Math.random() * 100,
+          transactions: Math.floor(Math.random() * 20)
+        })),
+        topEarningExtensions: [{
+          extensionSlug: 'sample-extension-1',
+          name: 'Sample Extension 1',
+          revenue: Math.random() * 500,
+          paidInstallations: Math.floor(Math.random() * 100),
+          arpu: Math.random() * 10
+        }]
+      };
+      return mockRevenue;
+    },
+    /**
+     * Get recent analytics events
+     */
+    recentAnalyticsEvents: async (root, args,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    ctx) => {
+      if (logger) {
+        logger.debug('recentAnalyticsEvents args [%j]', args);
+      }
+      const limit = args.limit || 50;
+      const eventTypes = ['download', 'install', 'uninstall', 'update', 'view'];
+      const regions = ['US', 'UK', 'DE', 'FR', 'JP'];
+      const mockEvents = Array.from({
+        length: Math.min(limit, 20)
+      }, () => ({
+        eventType: eventTypes[Math.floor(Math.random() * eventTypes.length)],
+        extensionSlug: `ext-${Math.floor(Math.random() * 10)}`,
+        publisherId: args.publisherId,
+        timestamp: new Date(Date.now() - Math.random() * 86400000).toISOString(),
+        metadata: JSON.stringify({
+          source: 'marketplace',
+          userAgent: 'VS Code'
+        }),
+        region: regions[Math.floor(Math.random() * regions.length)],
+        version: `1.${Math.floor(Math.random() * 10)}.${Math.floor(Math.random() * 10)}`
+      }));
+      return mockEvents.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+    }
+  },
+  Mutation: {
+    /**
+     * Track an analytics event
+     */
+    trackAnalyticsEvent: async (root, args,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    ctx) => {
+      if (logger) {
+        logger.debug('trackAnalyticsEvent args [%j]', args);
+      }
+      const eventId = `evt_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+      // Create analytics event for real-time subscriptions
+      const analyticsEvent = {
+        eventType: args.input.eventType,
+        extensionSlug: args.input.extensionSlug,
+        publisherId: 'publisher-id',
+        // Would be resolved from extension
+        timestamp: new Date().toISOString(),
+        metadata: args.input.metadata,
+        region: args.input.region,
+        version: args.input.version
+      };
+      // Emit to subscriptions
+      pubsub.publish('ANALYTICS_EVENT', {
+        analyticsEvents: analyticsEvent
+      });
+      if (args.input.eventType === 'download') {
+        pubsub.publish('DOWNLOAD_EVENT', {
+          downloadEvents: analyticsEvent
+        });
+      }
+      if (args.input.eventType === 'install') {
+        pubsub.publish('INSTALLATION_EVENT', {
+          installationEvents: analyticsEvent
+        });
+      }
+      return {
+        success: true,
+        message: `Analytics event '${args.input.eventType}' tracked successfully`,
+        eventId
+      };
+    }
+  },
+  Subscription: {
+    /**
+     * Subscribe to real-time analytics events
+     */
+    analyticsEvents: {
+      subscribe: (root, args) => {
+        if (logger) {
+          logger.debug('analyticsEvents subscription for publisher [%s]', args.publisherId);
+        }
+        return pubsub.asyncIterator('ANALYTICS_EVENT');
+      }
+    },
+    /**
+     * Subscribe to download events
+     */
+    downloadEvents: {
+      subscribe: (root, args) => {
+        if (logger) {
+          logger.debug('downloadEvents subscription for publisher [%s]', args.publisherId);
+        }
+        return pubsub.asyncIterator('DOWNLOAD_EVENT');
+      }
+    },
+    /**
+     * Subscribe to installation events
+     */
+    installationEvents: {
+      subscribe: (root, args) => {
+        if (logger) {
+          logger.debug('installationEvents subscription for publisher [%s]', args.publisherId);
+        }
+        return pubsub.asyncIterator('INSTALLATION_EVENT');
+      }
+    }
+  }
+});export{publisherAnalyticsResolver};//# sourceMappingURL=publisher-analytics-resolver.js.map

package/lib/graphql/resolvers/publisher-analytics-resolver.js.map

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

package/lib/graphql/resolvers/publisher-resolver.d.ts

@@ -0,0 +1,5 @@
+import { PubSub } from 'graphql-subscriptions';
+import { CdmLogger } from '@cdm-logger/core';
+import { IResolvers } from 'common/server';
+export declare const publisherResolver: (pubsub: PubSub, logger?: CdmLogger.ILogger) => IResolvers;
+//# sourceMappingURL=publisher-resolver.d.ts.map

package/lib/graphql/resolvers/publisher-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publisher-resolver.d.ts","sourceRoot":"","sources":["../../../src/graphql/resolvers/publisher-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EACH,UAAU,EAMb,MAAM,eAAe,CAAC;AAEvB,eAAO,MAAM,iBAAiB,GAAI,QAAQ,MAAM,EAAE,SAAS,SAAS,CAAC,OAAO,KAAG,UAqO7E,CAAC"}

package/lib/graphql/resolvers/publisher-resolver.js

@@ -0,0 +1,183 @@
+import {PublisherOrderBy}from'common/server';const publisherResolver = (pubsub, logger) => ({
+  Query: {
+    async publisherStats(root, args, {
+      marketplacePublisherService
+    }) {
+      if (logger) {
+        logger.debug('publisherStats query with args [%j]', args);
+      }
+      const stats = await marketplacePublisherService.getPublisherStats(args.publisherId);
+      // Cast service result to GraphQL interface - field resolvers will handle computed fields
+      return stats;
+    },
+    async publishers(root, args, {
+      marketplacePublisherService
+    }) {
+      if (logger) {
+        logger.debug('publishers query with args [%j]', args);
+      }
+      const {
+        first = 20,
+        skip = 0,
+        search,
+        orderBy = PublisherOrderBy.CreatedDesc
+      } = args;
+      // Note: verified filtering not implemented yet in service layer
+      // Convert GraphQL orderBy enum to service format
+      const serviceOrderBy = orderBy === PublisherOrderBy.CreatedDesc ? 'createdAt' : 'createdAt';
+      const serviceOrderDirection = orderBy === PublisherOrderBy.CreatedDesc ? 'DESC' : 'ASC';
+      try {
+        const result = await marketplacePublisherService.findPublishers(search, serviceOrderBy, serviceOrderDirection, first, skip);
+        return {
+          nodes: result.publishers,
+          totalCount: result.totalCount,
+          hasNextPage: skip + first < result.totalCount,
+          hasPreviousPage: skip > 0
+        };
+      } catch (error) {
+        if (logger) {
+          logger.error('publishers query error: %s', error.message);
+        }
+        // Return empty result instead of null to satisfy non-nullable schema
+        return {
+          nodes: [],
+          totalCount: 0,
+          hasNextPage: false,
+          hasPreviousPage: false
+        };
+      }
+    },
+    async publisher(root, args, {
+      marketplacePublisherService
+    }) {
+      if (logger) {
+        logger.debug('publisher query with args [%j]', args);
+      }
+      try {
+        const publisher = await marketplacePublisherService.findByPublisherName(args.name);
+        return publisher;
+      } catch (error) {
+        if (logger) {
+          logger.error('publisher query error: %s', error.message);
+        }
+        return null;
+      }
+    }
+  },
+  Mutation: {
+    async createPublisherMutation(root, args, {
+      marketplacePublisherService
+    }) {
+      if (logger) {
+        logger.debug('createPublisherMutation with args [%j]', args);
+      }
+      try {
+        const publisher = await marketplacePublisherService.createPublisher(args.input);
+        return {
+          publisher: publisher,
+          success: true,
+          error: null
+        };
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (logger) {
+          logger.error('createPublisherMutation error: %s', errorMessage);
+        }
+        throw error;
+      }
+    },
+    async updatePublisherMutation(root, args, {
+      marketplacePublisherService
+    }) {
+      if (logger) {
+        logger.debug('updatePublisherMutation with args [%j]', args);
+      }
+      try {
+        const publisher = await marketplacePublisherService.updatePublisher(args.id, args.input);
+        return {
+          publisher: publisher ? publisher : null,
+          success: true,
+          error: null
+        };
+      } catch (error) {
+        if (logger) {
+          logger.error('updatePublisherMutation error: %s', error.message);
+        }
+        return {
+          publisher: null,
+          success: false,
+          error: error.message
+        };
+      }
+    },
+    async verifyPublisherMutation(root, args, {
+      marketplacePublisherService
+    }) {
+      if (logger) {
+        logger.debug('verifyPublisherMutation with args [%j]', args);
+      }
+      try {
+        const publisher = await marketplacePublisherService.verifyPublisher(args.id);
+        return {
+          publisher: publisher ? publisher : null,
+          success: true,
+          error: null
+        };
+      } catch (error) {
+        if (logger) {
+          logger.error('verifyPublisherMutation error: %s', error.message);
+        }
+        return {
+          publisher: null,
+          success: false,
+          error: error.message
+        };
+      }
+    }
+  },
+  ExtensionRegistry: {
+    // Publisher-related queries are now in root Query section
+  },
+  MarketplacePublisher: {
+    tenant: (parent, args, {
+      tenantDataLoader
+    }) => {
+      // Implement tenant resolver logic here
+      const tenantId = String(parent.tenant || '');
+      if (!tenantId) {
+        return null;
+      }
+      return tenantDataLoader.load(tenantId);
+    },
+    extensionCount: root => root.extensionCount || 0,
+    totalDownloads: root => root.totalDownloads || 0,
+    viewerCanManage: () => false,
+    // TODO: Implement proper authorization logic
+    // Analytics computed from time series collection
+    async stats(root, args, {
+      publisherEventService
+    }) {
+      if (logger) {
+        logger.debug('Computing publisher stats for publisherId [%s]', root.id);
+      }
+      return publisherEventService.getPublisherStats(root.id);
+    },
+    async analytics(root, args, {
+      publisherEventService
+    }) {
+      if (logger) {
+        logger.debug('Computing publisher analytics for publisherId [%s], period [%s - %s]', root.id, args.startDate, args.endDate);
+      }
+      return publisherEventService.getPublisherAnalytics(root.id, new Date(args.startDate), new Date(args.endDate), args.granularity);
+    },
+    async trends(root, args, {
+      publisherEventService
+    }) {
+      if (logger) {
+        logger.debug('Computing publisher trends for publisherId [%s], days [%d]', root.id, args.days);
+      }
+      const result = await publisherEventService.getPublisherTrends(root.id, args.days);
+      return result;
+    }
+  }
+});export{publisherResolver};//# sourceMappingURL=publisher-resolver.js.map

package/lib/graphql/resolvers/publisher-resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"publisher-resolver.js","sources":["../../../src/graphql/resolvers/publisher-resolver.ts"],"sourcesContent":[null],"names":[],"mappings":"6CACS,MAAA,mCAAoC,MAAA;AAC7C,EAAA,KAAO,EACH;AAQJ,IAAA,MAAA,cAAa,CAAA,IAAA,EAAA,IAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"registry-extension-resolver.d.ts","sourceRoot":"","sources":["../../../src/graphql/resolvers/registry-extension-resolver.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAsB,UAAU,EAAE,MAAM,eAAe,CAAC;AAK/D,eAAO,MAAM,QAAQ,GAAI,QAAQ,MAAM,EAAE,SAAS,SAAS,CAAC,OAAO,KAAG,UA+LpE,CAAC"}
+{"version":3,"file":"registry-extension-resolver.d.ts","sourceRoot":"","sources":["../../../src/graphql/resolvers/registry-extension-resolver.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAsB,UAAU,EAAE,MAAM,eAAe,CAAC;AAE/D,eAAO,MAAM,QAAQ,GAAI,QAAQ,MAAM,EAAE,SAAS,SAAS,CAAC,OAAO,KAAG,UAsDpE,CAAC"}

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

@@ -1,178 +1,45 @@
-import*as url from'url';/* eslint-disable no-unused-expressions */
-const bundleUrlGenerator = (extensionSlug, version) => url.resolve(process.env.BACKEND_URL, `_registry/${extensionSlug}/${version}`);
 const resolver = (pubsub, logger) => ({
-  Contributes: {
-    menus: root => {
-      let result;
-      // const manifest = JSON.parse(root.manifest);
-      // console.log('manifest======>', manifest);
-      const {
-        menus
-      } = root;
-      console.log('menus=========>', menus);
-      try {
-        result = {
-          commandPalette: menus.commandPalette || [],
-          explorer: {
-            context: menus['explorer/context'] || []
-          },
-          editor: {
-            context: menus['editor/context'] || [],
-            title: {
-              own: menus['editor/title'] || [],
-              context: menus['editor/title/context'] || []
-            }
-          },
-          debug: {
-            callstack: {
-              context: menus['debug/callstack/context'] || []
-            },
-            toolbar: menus['debug/toolbar'] || []
-          },
-          scm: {
-            title: menus['scm/title'] || [],
-            resourceGroup: {
-              context: menus['scm/resourceGroup/context'] || []
-            },
-            resource: {
-              context: menus['scm/resource/context'] || []
-            },
-            change: {
-              title: menus['scm/change/title'] || []
-            }
-          },
-          view: {
-            title: menus['view/title'] || [],
-            item: {
-              context: menus['view/item/context'] || []
-            }
-          },
-          touchBar: menus.touchBar || []
-        };
-      } catch (err) {
-        console.log('err', err);
-      }
-      console.log('result====>', result, result.editor);
-      return result;
-    }
-  },
-  ExtensionRegistry: {
-    async extensions(root, args, ctx) {
-      logger && logger.debug('args [%j]', args);
-      const nodes = await ctx.registryExtensionService.findExtensions(args.first, args.query, args.local, args.remote, args.prioritizeExtensionIDs);
-      return {
-        nodes: nodes,
-        pageInfo: {
-          hasNextPage: false,
-          hasPreviousPage: false
-        },
-        totalCount: nodes.length
-      };
-    },
-    async extension(root, args, ctx) {
-      return ctx.registryExtensionService.findExtension(args.extensionSlug);
-    },
-    async releases(root, args, ctx) {
-      return ctx.registryExtensionService.extensionReleases(args.extensionSlug);
-    },
-    async publishers(root, args, ctx) {
-      return {
-        nodes: [],
-        pageInfo: {
-          hasNextPage: false,
-          hasPreviousPage: false
-        },
-        totalCount: 0
-      };
-    },
-    async viewerPublishers(root, args, ctx) {
-      return [];
-    },
-    async localExtensionIDPrefix(root, args, ctx) {
-      return null;
-    }
-  },
-  ExtensionRelease: {
-    bundleURL: root => bundleUrlGenerator(root.extensionSlug, root.version)
-  },
-  ExtensionManifest: {
-    bundleURL: ({
-      version,
-      extensionSlug
-    }) => bundleUrlGenerator(extensionSlug, version)
-  },
   RegistryExtension: {
+    // Resolve manifest from the current release
     manifest: root => {
-      let result;
-      // console.log('root=================>', JSON.parse(root.manifest));
+      if (!root.releases || root.releases.length === 0) {
+        return null;
+      }
+      // Find the current release that matches the extension's version
+      const currentRelease = root.releases.find(release => release.version === root.version);
+      if (!currentRelease || !currentRelease.manifest) {
+        return null;
+      }
       try {
-        result = {
-          ...root.manifest,
-          extensionSlug: root.extensionSlug,
-          raw: JSON.stringify(root.manifest)
+        // Parse the manifest from the release (stored as JSON string)
+        const parsedManifest = typeof currentRelease.manifest === 'string' ? JSON.parse(currentRelease.manifest) : currentRelease.manifest;
+        return {
+          ...parsedManifest,
+          raw: currentRelease.manifest // Keep the original raw JSON for backwards compatibility
+        };
+      } catch (error) {
+        logger?.warn('Failed to parse extension manifest for', root.extensionSlug, ':', error);
+        // Fallback to raw string format for backwards compatibility
+        return {
+          raw: currentRelease.manifest
         };
-      } catch (err) {
-        result = {};
       }
-      return result;
-    },
-    url: root => bundleUrlGenerator(root.extensionSlug, root.version)
-  },
-  Query: {
-    // namespace for running all extension registry queries
-    extensionRegistry() {
-      return {};
-    },
-    /// DEPRECATED: Remove all fo the following resolvers as they moved to namespace ExtensionRegistry
-    async extensions(root, args, ctx) {
-      logger && logger.debug('args [%j]', args);
-      const nodes = await ctx.registryExtensionService.findExtensions(args.first, args.query, args.local, args.remote, args.prioritizeExtensionIDs);
-      // const res = { nodes: {...nodes, manifest: JSON.parse(nodes[0].manifest)} };
-      // console.log('nodes==>', nodes);
-      //  nodes = nodes.map(el => {
-      //    return {
-      //      ...JSON.parse(JSON.stringify(el)),
-      //      manifest: JSON.parse(el.manifest),
-      //    };
-      //  });
-      //   console.log('nodes=======after>', nodes);
-      return {
-        nodes: nodes,
-        pageInfo: {
-          hasNextPage: false,
-          hasPreviousPage: false
-        },
-        totalCount: nodes.length
-      };
-    },
-    async extension(root, args, ctx) {
-      return ctx.registryExtensionService.findExtension(args.extensionSlug);
     },
-    async releases(root, args, ctx) {
-      return ctx.registryExtensionService.extensionReleases(args.extensionSlug);
-    }
-  },
-  Mutation: {
-    async createExtension(root, args, ctx) {
-      const extension = await ctx.registryExtensionService.createExtension(args.publisher, args.name);
-      return extension;
-    },
-    updateExtension(root, args, ctx) {
-      return ctx.registryExtensionService.updateExtensionName(args.extension, args.name);
-    },
-    async deleteExtension(root, args, ctx) {
-      const result = await ctx.registryExtensionService.deleteExtension(args.extension);
-      return {
-        success: !!result,
-        message: 'Extension deleted successfully'
-      };
-    },
-    async publishExtension(root, args, ctx) {
-      const extension = await ctx.registryExtensionService.publishExtension({
-        ...args
-      });
+    // Resolve releases
+    releases: root => root.releases || [],
+    // Resolve the current version directly from the extension
+    version: root => root.version || null,
+    // Resolve publisher
+    publisher: (root, args, ctx) => {
+      if (!root.publisher) {
+        return null;
+      }
+      // For now, return a basic publisher object - this should be replaced with proper dataloader
       return {
-        extension: extension
+        id: String(root.publisher),
+        name: 'Publisher Name',
+        // This should come from the actual publisher data
+        __typename: 'RegistryPublisher'
       };
     }
   }

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

@@ -1 +1 @@
-{"version":3,"file":"registry-extension-resolver.js","sources":["../../../src/graphql/resolvers/registry-extension-resolver.ts"],"sourcesContent":[null],"names":[],"mappings":"wBAEA;AAEA,MAAA,kBAAyC,GAAM,gBAAgB,OAAA,KAAA,GAAA,CAAA,OAAA,CAAA,OAAA,CAAA,GAAA,CAAA,WAAA,EAAA,CAAA,UAAA,EAAA,aAAA,CAAA,CAAA,EAAA,OAAA,CAAA,CAAA,CAAA;AAK/D,MAAA,QAAa,GAAA,CAAA,MAAY,EAAA,MAAA,MAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"registry-extension-resolver.js","sources":["../../../src/graphql/resolvers/registry-extension-resolver.ts"],"sourcesContent":[null],"names":[],"mappings":"AAES,MAAA,QAAQ;AACjB,EAAA,iBAAkB,EAAE;AACpB;AAEA,IAAA,QAAA,EAAA,IAAO,IAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}