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

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

@@ -0,0 +1,289 @@
+const resolver = (pubsub, logger) => ({
+  InstalledExtension: {
+    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;
+      }
+    }
+  },
+  Query: {
+    /**
+     * Get all installed extensions for the current user/organization
+     */
+    async installedExtensions(root, {
+      enabled,
+      orgName
+    }, {
+      userContext,
+      installedExtensionService,
+      slugService
+    }) {
+      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;
+    },
+    /**
+     * Get a specific installed extension
+     */
+    async installedExtension(root, args, {
+      userContext,
+      installedExtensionService,
+      slugService
+    }) {
+      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,
+      slugService
+    }) {
+      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,
+      slugService
+    }) {
+      let orgId;
+      if (args.orgName) {
+        orgId = await slugService.resolveOrganizationSlug(args.orgName);
+      }
+      return installedExtensionService.checkForUpdates(orgId, args.extensionSlug);
+    }
+  },
+  Mutation: {
+    /**
+     * Install an extension from the registry
+     */
+    async installExtension(root, args, {
+      userContext,
+      installedExtensionService,
+      registryExtensionService,
+      slugService
+    }) {
+      try {
+        // 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,
+          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,
+          message: `Extension ${args.input.extensionSlug} installed successfully`
+        };
+      } catch (error) {
+        return {
+          success: false,
+          extension: null,
+          message: error.message || `Failed to install extension ${args.input.extensionSlug}`
+        };
+      }
+    },
+    /**
+     * Uninstall an extension
+     */
+    async uninstallExtension(root, args, {
+      userContext,
+      installedExtensionService,
+      registryExtensionService,
+      slugService
+    }) {
+      try {
+        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, {
+            installed: false
+          });
+        }
+        return {
+          success,
+          message: success ? `Extension ${args.extensionSlug} uninstalled successfully` : `Failed to uninstall extension ${args.extensionSlug}`
+        };
+      } catch (error) {
+        return {
+          success: false,
+          message: error.message || `Failed to uninstall extension ${args.extensionSlug}`
+        };
+      }
+    },
+    /**
+     * Enable or disable an extension
+     */
+    async toggleExtension(root, args, {
+      userContext,
+      installedExtensionService,
+      slugService
+    }) {
+      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,
+        message: `Extension ${args.extensionSlug} ${args.enabled ? 'enabled' : 'disabled'} successfully`
+      };
+    },
+    /**
+     * Update extension settings
+     */
+    async updateExtensionSettings(root, args, {
+      userContext,
+      installedExtensionService,
+      slugService
+    }) {
+      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,
+        message: `Extension ${args.extensionSlug} settings updated successfully`
+      };
+    },
+    /**
+     * Update an extension to a newer version
+     */
+    async updateExtensionVersion(root, args, {
+      userContext,
+      installedExtensionService,
+      slugService
+    }) {
+      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,
+        message: `Extension ${args.extensionSlug} updated to version ${args.version} successfully`
+      };
+    },
+    /**
+     * Sync installed extensions with registry
+     */
+    async syncExtensionsWithRegistry(root, args, {
+      userContext,
+      installedExtensionService,
+      slugService
+    }) {
+      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'
+      };
+    },
+    /**
+     * Clean up deprecated or removed extensions
+     */
+    async cleanupExtensions(root, args, {
+      userContext,
+      installedExtensionService,
+      slugService
+    }) {
+      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`
+      };
+    }
+  }
+});export{resolver};//# sourceMappingURL=installed-extension-resolver.js.map

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

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

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,EAKb,MAAM,eAAe,CAAC;AAEvB,eAAO,MAAM,iBAAiB,GAAI,QAAQ,MAAM,EAAE,SAAS,SAAS,CAAC,OAAO,KAAG,UA6N7E,CAAC"}