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

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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

@@ -1,2 +1,248 @@
-export * from './resolvers';
+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":"AAAA,cAAc,aAAa,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

@@ -0,0 +1 @@
+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/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/graphql/resolvers/installed-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=installed-extension-resolver.d.ts.map

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

@@ -0,0 +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,EAA0C,MAAM,eAAe,CAAC;AAExG,eAAO,MAAM,QAAQ,GAAI,QAAQ,MAAM,EAAE,SAAS,SAAS,CAAC,OAAO,KAAG,UAyVpE,CAAC"}