@adminide-stack/marketplace-module-server 12.0.4-alpha.4 → 12.0.4-alpha.402

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

@@ -0,0 +1,176 @@
+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) {
+        if (logger) {
+          logger.error('createPublisherMutation error: %s', error.message);
+        }
+        return {
+          publisher: null,
+          success: false,
+          error: error.message
+        };
+      }
+    },
+    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: {
+    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;AAOJ,IAAA,MAAA,cAAa,CAAA,IAAA,EAAA,IAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/graphql/resolvers/registry-extension-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 resolver: (pubsub: PubSub, logger?: CdmLogger.ILogger) => IResolvers;
+//# sourceMappingURL=registry-extension-resolver.d.ts.map

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

@@ -0,0 +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;AAE/D,eAAO,MAAM,QAAQ,GAAI,QAAQ,MAAM,EAAE,SAAS,SAAS,CAAC,OAAO,KAAG,UAsDpE,CAAC"}

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

@@ -0,0 +1,46 @@
+const resolver = (pubsub, logger) => ({
+  RegistryExtension: {
+    // Resolve manifest from the current release
+    manifest: root => {
+      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 {
+        // 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
+        };
+      }
+    },
+    // 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 {
+        id: String(root.publisher),
+        name: 'Publisher Name',
+        // This should come from the actual publisher data
+        __typename: 'RegistryPublisher'
+      };
+    }
+  }
+});export{resolver};//# sourceMappingURL=registry-extension-resolver.js.map

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

@@ -0,0 +1 @@
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}