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

package/lib/containers/module.d.ts

@@ -1,11 +1,11 @@
 import { interfaces } from 'inversify';
-import { IRegistryExtensionService, IInstalledExtensionService } from 'common/server';
-import { RegistryExtensionDataLoader } from '../dataloaders';
+import { IInstalledExtensionService, IMarketplacePublisherService, IPublisherEventService, IExtensionGalleryService } from 'common/server';
 export declare const extensionModule: (settings: any) => interfaces.ContainerModule;
 declare const createServiceFunc: (container: interfaces.Container) => {
-    registryExtensionService: IRegistryExtensionService;
     installedExtensionService: IInstalledExtensionService;
-    registryExtensionDataLoader: RegistryExtensionDataLoader;
+    publisherService: IMarketplacePublisherService;
+    publisherEventService: IPublisherEventService;
+    extensionGalleryService: IExtensionGalleryService;
 };
 export { createServiceFunc };
 //# sourceMappingURL=module.d.ts.map

package/lib/containers/module.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../src/containers/module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,UAAU,EAAE,MAAM,WAAW,CAAC;AACxD,OAAO,EAEH,yBAAyB,EAEzB,0BAA0B,EAE7B,MAAM,eAAe,CAAC;AAGvB,OAAO,EAAE,2BAA2B,EAAE,MAAM,gBAAgB,CAAC;AAE7D,eAAO,MAAM,eAAe,EAAE,CAAC,QAAQ,EAAE,GAAG,KAAK,UAAU,CAAC,eAgCtD,CAAC;AAGP,QAAA,MAAM,iBAAiB,GAAI,WAAW,UAAU,CAAC,SAAS;;;;CAIxD,CAAC;AAEH,OAAO,EAAE,iBAAiB,EAAE,CAAC"}
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../src/containers/module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,UAAU,EAAE,MAAM,WAAW,CAAC;AACxD,OAAO,EAEH,0BAA0B,EAG1B,4BAA4B,EAC5B,sBAAsB,EACtB,wBAAwB,EAE3B,MAAM,eAAe,CAAC;AAWvB,eAAO,MAAM,eAAe,EAAE,CAAC,QAAQ,EAAE,GAAG,KAAK,UAAU,CAAC,eAgDtD,CAAC;AAGP,QAAA,MAAM,iBAAiB,GAAI,WAAW,UAAU,CAAC,SAAS;;;;;CAKxD,CAAC;AAEH,OAAO,EAAE,iBAAiB,EAAE,CAAC"}

package/lib/containers/module.js

@@ -1,13 +1,18 @@
-import {ContainerModule}from'inversify';import {SERVER_TYPES}from'common/server';import {RegistryExtensionService}from'../services/extension-service.js';import'../services/installed-extension-service.js';import {InstalledExtensionServiceExt}from'../services/installed-extension-service-ext.js';import'../store/models/registry-extension-model.js';import'../store/models/installed-extension-model.js';import {RegistryExtensionRepository}from'../store/repositories/registry-extension-repository.js';import {InstalledExtensionRepository}from'../store/repositories/installed-extension-repository.js';import {RegistryExtensionDataLoader}from'../dataloaders/registry-extension-data-loader.js';const extensionModule = settings => new ContainerModule(bind => {
+import {ContainerModule}from'inversify';import {SERVER_TYPES}from'common/server';import'../services/installed-extension-service.js';import {InstalledExtensionServiceExt}from'../services/installed-extension-service-ext.js';import {MarketplacePublisherService}from'../services/publisher-service.js';import {PublisherEventService}from'../services/publisher-event-service.js';import {ExtensionGalleryService}from'../services/extension-gallery-service.js';import {ExtensionGalleryRepository}from'../services/extension-gallery-repository.js';import'../store/models/installed-extension-model.js';import'../store/models/publisher-model.js';import {InstalledExtensionRepository}from'../store/repositories/installed-extension-repository.js';import {MarketplacePublisherRepository}from'../store/repositories/publisher-repository.js';import {DropOldPublisherNameIndexMigration}from'../migrations/dbMigrations/DropOldPublisherIndexMigration.js';const extensionModule = settings => new ContainerModule(bind => {
   bind(SERVER_TYPES.IExtensionMongoConnection).toConstantValue(settings.mongoConnection);
-  // Registry Extension Service
-  bind(SERVER_TYPES.IRegistryExtensionService).to(RegistryExtensionService).inSingletonScope().whenTargetIsDefault();
-  // Registry Extension Repository
-  bind(SERVER_TYPES.IRegistryExtensionRepository).to(RegistryExtensionRepository).inSingletonScope().whenTargetIsDefault();
   // Installed Extension Service
   bind(SERVER_TYPES.IInstalledExtensionService).to(InstalledExtensionServiceExt).inSingletonScope().whenTargetIsDefault();
   // Installed Extension Repository
   bind(SERVER_TYPES.IInstalledExtensionRepository).to(InstalledExtensionRepository).inSingletonScope().whenTargetIsDefault();
-  // DataLoaders
-  bind(SERVER_TYPES.IRegistryExtensionDataLoader).to(RegistryExtensionDataLoader).inRequestScope(); // Important: Request scope for DataLoader caching
+  // Publisher Service
+  bind(SERVER_TYPES.IMarketplacePublisherService).to(MarketplacePublisherService).inSingletonScope().whenTargetIsDefault();
+  // Publisher Repository
+  bind(SERVER_TYPES.IMarketplacePublisherRepository).to(MarketplacePublisherRepository).inSingletonScope().whenTargetIsDefault();
+  // Publisher Event Service
+  bind(SERVER_TYPES.IPublisherEventService).to(PublisherEventService).inSingletonScope().whenTargetIsDefault();
+  // Extension Gallery Repository
+  bind(SERVER_TYPES.IExtensionGalleryRepository).to(ExtensionGalleryRepository).inSingletonScope().whenTargetIsDefault();
+  // Extension Gallery Service
+  bind(SERVER_TYPES.IExtensionGalleryService).to(ExtensionGalleryService).inSingletonScope().whenTargetIsDefault();
+  bind('MongodbMigration').to(DropOldPublisherNameIndexMigration).whenTargetNamed(DropOldPublisherNameIndexMigration.name);
 });export{extensionModule};//# sourceMappingURL=module.js.map

package/lib/containers/module.js.map

@@ -1 +1 @@
-{"version":3,"file":"module.js","sources":["../../src/containers/module.ts"],"sourcesContent":[null],"names":[],"mappings":";;;EAmDG,IAAA,CAAA,YAAA,CAAA,yBAAA,CAAA,CAAA,EAAA,CAAA,wBAAA,CAAA,CAAA,gBAAA,EAAA,CAAA,mBAAA,EAAA;AAEH;;;;;;;;"}
+{"version":3,"file":"module.js","sources":["../../src/containers/module.ts"],"sourcesContent":[null],"names":[],"mappings":";;;EA6EG,IAAA,CAAA,YAAA,CAAA,0BAAA,CAAA,CAAA,EAAA,CAAA,4BAAA,CAAA,CAAA,gBAAA,EAAA,CAAA,mBAAA,EAAA;AAEH;;;;;;;;;;;;;"}

package/lib/dataloaders/index.d.ts

@@ -1,2 +1,2 @@
-export { RegistryExtensionDataLoader } from './registry-extension-data-loader';
+export * from './publisher-data-loader';
 //# sourceMappingURL=index.d.ts.map

package/lib/dataloaders/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/dataloaders/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,kCAAkC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/dataloaders/index.ts"],"names":[],"mappings":"AACA,cAAc,yBAAyB,CAAC"}

package/lib/dataloaders/publisher-data-loader.d.ts

@@ -0,0 +1,6 @@
+import { IPublisherEventService, AsDomainType, IMarketplacePublisherModel } from 'common/server';
+import { BulkDataLoader2 } from '@common-stack/store-mongo';
+export declare class PublisherDataLoader extends BulkDataLoader2<AsDomainType<IMarketplacePublisherModel>> {
+    constructor(publisherService: IPublisherEventService);
+}
+//# sourceMappingURL=publisher-data-loader.d.ts.map

package/lib/dataloaders/publisher-data-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publisher-data-loader.d.ts","sourceRoot":"","sources":["../../src/dataloaders/publisher-data-loader.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,sBAAsB,EAGtB,YAAY,EACZ,0BAA0B,EAC7B,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAE5D,qBACa,mBAAoB,SAAQ,eAAe,CAAC,YAAY,CAAC,0BAA0B,CAAC,CAAC;gBAG1F,gBAAgB,EAAE,sBAAsB;CAI/C"}

package/lib/demo/test-graphql-examples.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Example GraphQL calls for testing the installExtension mutation
+ * with the new orgName parameter support
+ */
+declare const basicInstallExample: {
+    query: string;
+    variables: {
+        input: {
+            extensionSlug: string;
+            version: string;
+            settings: {
+                enabled: boolean;
+            };
+        };
+    };
+};
+declare const orgInstallExample: {
+    query: string;
+    variables: {
+        input: {
+            extensionSlug: string;
+            version: string;
+            orgName: string;
+            settings: {
+                enabled: boolean;
+                userConfig: {
+                    theme: string;
+                    notifications: boolean;
+                    autoSave: boolean;
+                };
+            };
+            policies: {
+                autoUpdate: boolean;
+                allowBeta: boolean;
+            };
+        };
+    };
+};
+declare const queryExtensionsExample: {
+    query: string;
+    variables: {
+        orgName: string;
+        enabled: boolean;
+    };
+};
+declare const expectedResponse: {
+    data: {
+        installExtension: {
+            success: boolean;
+            message: string;
+            extension: {
+                id: string;
+                status: string;
+                installedVersion: string;
+                extension: {
+                    extensionSlug: string;
+                    name: string;
+                    version: string;
+                };
+                settings: {
+                    effectiveEnabled: boolean;
+                    userConfig: {
+                        theme: string;
+                        notifications: boolean;
+                        autoSave: boolean;
+                    };
+                };
+            };
+        };
+    };
+};
+export { basicInstallExample, orgInstallExample, queryExtensionsExample, expectedResponse };
+//# sourceMappingURL=test-graphql-examples.d.ts.map

package/lib/demo/test-graphql-examples.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-graphql-examples.d.ts","sourceRoot":"","sources":["../../src/demo/test-graphql-examples.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,QAAA,MAAM,mBAAmB;;;;;;;;;;;CAgCxB,CAAC;AAQF,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;CA0CtB,CAAC;AAOF,QAAA,MAAM,sBAAsB;;;;;;CAuB3B,CAAC;AAOF,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;CAyBrB,CAAC;AAqBF,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,CAAC"}

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

@@ -0,0 +1,220 @@
+type Context = {
+    user?: {
+        id: string;
+        name: string;
+        email: string;
+    };
+};
+type FormTemplatesInput = {
+    search?: string;
+    category?: string;
+    publisherId?: string;
+    installed?: boolean;
+    limit?: number;
+    offset?: number;
+};
+export declare const formTemplateResolvers: () => {
+    Query: {
+        marketplaceFormTemplates: (_: unknown, { input }: {
+            input?: FormTemplatesInput;
+        }, context: Context) => 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: Context) => 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: Context) => 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: Context) => 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>;
+        };
+    };
+};
+export {};
+//# sourceMappingURL=form-templates-resolver.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"form-templates-resolver.d.ts","sourceRoot":"","sources":["../../../src/graphql/resolvers/form-templates-resolver.ts"],"names":[],"mappings":"AAIA,KAAK,OAAO,GAAG;IACX,IAAI,CAAC,EAAE;QACH,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;CACL,CAAC;AAEF,KAAK,kBAAkB,GAAG;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAwCF,eAAO,MAAM,qBAAqB;;sCAInB,OAAO,aACC;YAAE,KAAK,CAAC,EAAE,kBAAkB,CAAA;SAAE,WAEhC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAsCb,OAAO,UACF;YAAE,EAAE,EAAE,MAAM,CAAA;SAAE,WAEb,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CAeb,OAAO,aAEC;YAAE,KAAK,EAAE,OAAO,CAAA;SAAE,WAEpB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CA4Bb,OAAO,aACC;YAAE,KAAK,EAAE;gBAAE,EAAE,EAAE,MAAM,CAAA;aAAE,CAAA;SAAE,WAE3B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAiCT,OAAO,mBACO;gBAAE,WAAW,CAAC,EAAE,MAAM,CAAA;aAAE;;;CASvD,CAAC"}

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

@@ -0,0 +1,170 @@
+import {PubSub}from'graphql-subscriptions';const pubsub = new PubSub();
+const mockFormTemplates = [{
+  id: '1',
+  name: 'Contact Form',
+  description: 'A comprehensive contact form with validation for business websites',
+  category: 'Contact Forms',
+  version: '1.2.0',
+  author: 'FormBuilder Team',
+  publisherId: 'formbuilder-team',
+  tags: ['contact', 'business', 'validation', 'responsive'],
+  schema: JSON.stringify({
+    type: 'object',
+    title: 'Contact Form',
+    properties: {
+      name: {
+        type: 'string',
+        title: 'Full Name'
+      },
+      email: {
+        type: 'string',
+        title: 'Email',
+        format: 'email'
+      },
+      message: {
+        type: 'string',
+        title: 'Message'
+      }
+    },
+    required: ['name', 'email', 'message']
+  }),
+  uiSchema: JSON.stringify({
+    message: {
+      'ui:widget': 'textarea'
+    }
+  }),
+  downloads: 1250,
+  rating: 4.5,
+  reviewCount: 28,
+  createdAt: new Date('2024-01-15'),
+  updatedAt: new Date('2024-08-20'),
+  installed: false,
+  preview: null,
+  publisher: {
+    id: 'formbuilder-team',
+    name: 'FormBuilder Team',
+    email: 'team@formbuilder.com'
+  }
+}];
+const formTemplateResolvers = () => ({
+  Query: {
+    marketplaceFormTemplates: async (
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _, {
+      input
+    },
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    context) => {
+      let filteredTemplates = mockFormTemplates;
+      if (input?.search) {
+        const searchTerm = input.search.toLowerCase();
+        filteredTemplates = filteredTemplates.filter(template => template.name.toLowerCase().includes(searchTerm) || template.description.toLowerCase().includes(searchTerm) || template.tags.some(tag => tag.toLowerCase().includes(searchTerm)));
+      }
+      if (input?.category) {
+        filteredTemplates = filteredTemplates.filter(template => template.category === input.category);
+      }
+      const limit = input?.limit || 10;
+      const offset = input?.offset || 0;
+      const totalCount = filteredTemplates.length;
+      const paginatedTemplates = filteredTemplates.slice(offset, offset + limit);
+      return {
+        nodes: paginatedTemplates,
+        totalCount,
+        pageInfo: {
+          hasNextPage: offset + limit < totalCount,
+          hasPreviousPage: offset > 0,
+          startCursor: paginatedTemplates.length > 0 ? paginatedTemplates[0].id : null,
+          endCursor: paginatedTemplates.length > 0 ? paginatedTemplates[paginatedTemplates.length - 1].id : null
+        }
+      };
+    },
+    marketplaceFormTemplate: async (
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _, {
+      id
+    },
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    context) => mockFormTemplates.find(template => template.id === id) || null,
+    marketplaceInstalledFormTemplates: async () => mockFormTemplates.filter(template => template.installed),
+    marketplaceMyFormTemplates: async () => [],
+    marketplacePopularFormTemplates: async () => [],
+    marketplaceRecentFormTemplates: async () => []
+  },
+  Mutation: {
+    marketplacePublishFormTemplate: async (
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    {
+      input
+    },
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    context) => {
+      try {
+        await pubsub.publish('FORM_TEMPLATE_EVENTS', {
+          formTemplateEvents: {
+            eventType: 'PUBLISHED',
+            formTemplate: {
+              id: '1'
+            },
+            timestamp: new Date(),
+            metadata: '{}'
+          }
+        });
+        return {
+          success: true,
+          message: 'Form template published successfully',
+          formTemplate: mockFormTemplates[0]
+        };
+      } catch {
+        return {
+          success: false,
+          message: 'Failed to publish form template',
+          formTemplate: null
+        };
+      }
+    },
+    marketplaceInstallFormTemplate: async (
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _, {
+      input
+    },
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    context) => ({
+      success: true,
+      message: 'Form template installed successfully',
+      formTemplate: mockFormTemplates.find(t => t.id === input.id)
+    }),
+    marketplaceUninstallFormTemplate: async () => ({
+      success: true,
+      message: 'Form template uninstalled successfully'
+    }),
+    marketplaceUpdateFormTemplate: async () => ({
+      success: true,
+      message: 'Form template updated successfully',
+      formTemplate: mockFormTemplates[0]
+    }),
+    marketplaceDeleteFormTemplate: async () => ({
+      success: true,
+      message: 'Form template deleted successfully'
+    }),
+    marketplaceRateFormTemplate: async () => ({
+      success: true,
+      message: 'Rating submitted successfully'
+    })
+  },
+  Subscription: {
+    marketplaceFormTemplateEvents: {
+      subscribe: (
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      _, {
+        publisherId
+      }) => {
+        if (publisherId) {
+          return pubsub.asyncIterator(`FORM_TEMPLATE_EVENTS_${publisherId}`);
+        }
+        return pubsub.asyncIterator('FORM_TEMPLATE_EVENTS');
+      }
+    }
+  }
+});export{formTemplateResolvers};//# sourceMappingURL=form-templates-resolver.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"form-templates-resolver.js","sources":["../../../src/graphql/resolvers/form-templates-resolver.ts"],"sourcesContent":[null],"names":[],"mappings":"2CAKI,MAAA,MAAO,GAAA,IAAA,MAAA,EAAA;uBACQ,GAAA,CAAA;SACX;QACA,cAAc;aAChB,EAAA,oEAAA;EACJ,QAAA,EAAA,eAAA;AAEF,EAAA;QACI,EAAM,kBAAU;aACP,EAAE,kBAAO;MAClB,EAAA,CAAA,SAAc,EAAA,UAAO,EAAA,YAAA,EAAA,YAAA,CAAA;QACrB,EAAA,IAAU,CAAA,SAAU,CAAA;IACpB,IAAA,EAAM,QAAQ;IACd,KAAA,EAAO,cAAS;IAClB,UAAA,EAAA;AAwCF,MAAA,IAAA,EAAA;;AAIe,QAAA,KAAA,EAAA;;AACsC,MAAA,KAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCtC;;AACmB,MAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiBnB,YAAA,YAAA,EAAA;cAEU,EAAA,EAAK;AAAW,aAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8B1B,KAAA,CAAA;AACU,IAAA,gCAAO,EAAA,aAAA;mBAAI;aAAU,EAAA;AAAE,KAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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

@@ -0,0 +1,15 @@
+export declare const resolver: () => {
+    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>;
+    };
+};
+//# sourceMappingURL=gallery-resolver.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gallery-resolver.d.ts","sourceRoot":"","sources":["../../../src/graphql/resolvers/gallery-resolver.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;CA6BnB,CAAC"}

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

@@ -0,0 +1,35 @@
+const resolver = () => ({
+  Query: {
+    instances: async (root, args, ctx) => ctx.extensionInstanceManager.extensions({}),
+    gallery: async (root, {
+      query = {}
+    }, ctx) => ctx.extensionGalleryService?.query(query) || null,
+    galleryExtension: async (root, {
+      extensionSlug
+    }, ctx) => ctx.extensionGalleryService?.getExtension({
+      id: extensionSlug
+    }) || null
+  },
+  Mutation: {
+    // removeExtension: async (root, { id }, ctx) =>
+    //     ctx.extensionManagementService.removeIfExists(id).then(() => true),
+    // install: async (root, { vsix }, ctx: { extensionManagementService: IExtensionManagementService }) =>
+    //     ctx.extensionManagementService.install(vsix),
+    startExtensionHost: async (root, args, ctx) => {
+      await ctx.extensionService.startExtensionHost();
+      return true;
+    }
+  }
+  // GalleryExtension: {
+  //     id: (root: IGalleryExtension, args, ctx) => `${root.publisher}.${root.name}`,
+  //     icon: (root, args, ctx) => ctx.gallery.getIcon(root, CancellationToken.None),
+  //     resources: async (root, args, ctx /*: { gallery: IExtensionGalleryService } */) => ({
+  //         icon: await ctx.gallery.getIcon(root, CancellationToken.None),
+  //         readme: await ctx.gallery.getReadme(root, CancellationToken.None),
+  //         license: await ctx.gallery.getLicense(root, CancellationToken.None),
+  //         changelog: await ctx.gallery.getChangelog(root, CancellationToken.None),
+  //         download: await ctx.gallery.getDownloadUrl(root, CancellationToken.None),
+  //         manifest: await ctx.gallery.getTextManifest(root, CancellationToken.None),
+  //     }),
+  // },
+});export{resolver};//# sourceMappingURL=gallery-resolver.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gallery-resolver.js","sources":["../../../src/graphql/resolvers/gallery-resolver.ts"],"sourcesContent":[null],"names":[],"mappings":"AAAA,MAAA,QAAa,GAAA,OAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}