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

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

@@ -0,0 +1,183 @@
+const resolver = (pubsub, logger) => ({
+  InstalledExtension: {
+    extension: (root, args, ctx) => {
+      // Check if extension exists and is not null/undefined before calling dataloader
+      if (!root.extension || root.extension === null || root.extension === undefined) {
+        return null;
+      }
+      const extensionSlug = String(root.extension); // Convert ObjectId to string
+      return ctx.registryExtensionDataLoader.load(extensionSlug);
+    }
+  },
+  Query: {
+    /**
+     * Get all installed extensions for the current tenant
+     */
+    async installedExtensions(root, args, {
+      userContext,
+      installedExtensionService
+    }) {
+      const query = {
+        tenantId: userContext.tenantId
+      };
+      if (args.enabled !== undefined) {
+        query['settings.effectiveEnabled'] = args.enabled;
+      }
+      const results = await installedExtensionService.getInstalledExtensions(query);
+      return results;
+    },
+    /**
+     * Get a specific installed extension
+     */
+    async installedExtension(root, args, {
+      userContext,
+      installedExtensionService
+    }) {
+      return installedExtensionService.getInstalledExtension(userContext.tenantId, args.extensionSlug);
+    },
+    /**
+     * Get installed extensions that need attention (updates, deprecated, etc.)
+     */
+    async extensionsNeedingAttention(root, args, {
+      userContext,
+      installedExtensionService
+    }) {
+      return installedExtensionService.getExtensionsNeedingAttention(userContext.tenantId);
+    },
+    /**
+     * Check for available updates
+     */
+    async extensionUpdates(root, args, {
+      userContext,
+      installedExtensionService
+    }) {
+      return installedExtensionService.checkForUpdates(userContext.tenantId, args.extensionSlug);
+    }
+  },
+  Mutation: {
+    /**
+     * Install an extension from the registry
+     */
+    async installExtension(root, args, {
+      userContext,
+      installedExtensionService,
+      registryExtensionService
+    }) {
+      try {
+        const installedExtension = await installedExtensionService.installExtension({
+          ...args.input,
+          tenantId: userContext.tenantId,
+          installedVersion: args.input.version,
+          installedBy: userContext.accountId
+        });
+        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
+    }) {
+      try {
+        const success = await installedExtensionService.uninstallExtension(userContext.tenantId, args.extensionSlug, userContext.accountId);
+        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
+    }) {
+      const extension = await installedExtensionService.toggleExtension(userContext.tenantId, args.extensionSlug, args.enabled, userContext.accountId);
+      return {
+        success: true,
+        extension: extension,
+        message: `Extension ${args.extensionSlug} ${args.enabled ? 'enabled' : 'disabled'} successfully`
+      };
+    },
+    /**
+     * Update extension settings
+     */
+    async updateExtensionSettings(root, args, {
+      userContext,
+      installedExtensionService
+    }) {
+      const extension = await installedExtensionService.updateExtensionSettings(userContext.tenantId, args.extensionSlug, args.settings, userContext.accountId);
+      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
+    }) {
+      const extension = await installedExtensionService.updateExtensionVersion(userContext.tenantId, args.extensionSlug, args.version, userContext.accountId);
+      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
+    }) {
+      await installedExtensionService.syncWithRegistry(userContext.tenantId);
+      return {
+        success: true,
+        message: 'Extensions synced with registry successfully'
+      };
+    },
+    /**
+     * Clean up deprecated or removed extensions
+     */
+    async cleanupExtensions(root, args, {
+      userContext,
+      installedExtensionService
+    }) {
+      const result = await installedExtensionService.cleanupExtensions(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,SAA8B,EAAA,CAAA,IAAY,EAAA,IAAA;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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;AAK/D,eAAO,MAAM,QAAQ,GAAI,QAAQ,MAAM,EAAE,SAAS,SAAS,CAAC,OAAO,KAAG,UA+LpE,CAAC"}

package/lib/graphql/resolvers/{resolvers.js → registry-extension-resolver.js}

@@ -1,15 +1,18 @@
-import*as url from'url';const bundleUrlGenerator = (extensionID, version) => url.resolve(process.env.BACKEND_URL, `_registry/${extensionID}/${version}`);
+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.menus;
+      const {
+        menus
+      } = root;
       console.log('menus=========>', menus);
       try {
         result = {
-          commandPalette: menus['commandPalette'] || [],
+          commandPalette: menus.commandPalette || [],
           explorer: {
             context: menus['explorer/context'] || []
           },
@@ -44,7 +47,7 @@ const resolver = (pubsub, logger) => ({
               context: menus['view/item/context'] || []
             }
           },
-          touchBar: menus['touchBar'] || []
+          touchBar: menus.touchBar || []
         };
       } catch (err) {
         console.log('err', err);
@@ -58,27 +61,45 @@ const resolver = (pubsub, logger) => ({
       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: nodes,
+        pageInfo: {
+          hasNextPage: false,
+          hasPreviousPage: false
+        },
+        totalCount: nodes.length
       };
     },
     async extension(root, args, ctx) {
-      return ctx.registryExtensionService.findExtension(args.extensionID);
+      return ctx.registryExtensionService.findExtension(args.extensionSlug);
     },
     async releases(root, args, ctx) {
-      return ctx.registryExtensionService.extensionReleases(args.extensionID);
+      return ctx.registryExtensionService.extensionReleases(args.extensionSlug);
     },
-    async publishers(root, args, ctx) {},
-    async viewerPublishers(root, args, ctx) {},
-    async localExtensionIDPrefix(root, args, ctx) {}
+    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.extensionID, root.version)
+    bundleURL: root => bundleUrlGenerator(root.extensionSlug, root.version)
   },
   ExtensionManifest: {
     bundleURL: ({
       version,
-      extensionID
-    }) => bundleUrlGenerator(extensionID, version)
+      extensionSlug
+    }) => bundleUrlGenerator(extensionSlug, version)
   },
   RegistryExtension: {
     manifest: root => {
@@ -86,14 +107,16 @@ const resolver = (pubsub, logger) => ({
       // console.log('root=================>', JSON.parse(root.manifest));
       try {
         result = {
-          ...JSON.parse(root.manifest),
-          extensionID: root.extensionID,
-          raw: root.manifest
+          ...root.manifest,
+          extensionSlug: root.extensionSlug,
+          raw: JSON.stringify(root.manifest)
         };
-      } catch (err) {}
+      } catch (err) {
+        result = {};
+      }
       return result;
     },
-    url: root => bundleUrlGenerator(root.extensionID, root.version)
+    url: root => bundleUrlGenerator(root.extensionSlug, root.version)
   },
   Query: {
     // namespace for running all extension registry queries
@@ -103,7 +126,7 @@ const resolver = (pubsub, logger) => ({
     /// DEPRECATED: Remove all fo the following resolvers as they moved to namespace ExtensionRegistry
     async extensions(root, args, ctx) {
       logger && logger.debug('args [%j]', args);
-      let nodes = await ctx.registryExtensionService.findExtensions(args.first, args.query, args.local, args.remote, args.prioritizeExtensionIDs);
+      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 => {
@@ -114,54 +137,43 @@ const resolver = (pubsub, logger) => ({
       //  });
       //   console.log('nodes=======after>', nodes);
       return {
-        nodes
+        nodes: nodes,
+        pageInfo: {
+          hasNextPage: false,
+          hasPreviousPage: false
+        },
+        totalCount: nodes.length
       };
     },
     async extension(root, args, ctx) {
-      return ctx.registryExtensionService.findExtension(args.extensionID);
+      return ctx.registryExtensionService.findExtension(args.extensionSlug);
     },
     async releases(root, args, ctx) {
-      return ctx.registryExtensionService.extensionReleases(args.extensionID);
+      return ctx.registryExtensionService.extensionReleases(args.extensionSlug);
     }
   },
   Mutation: {
     async createExtension(root, args, ctx) {
       const extension = await ctx.registryExtensionService.createExtension(args.publisher, args.name);
-      return {
-        extension
-      };
+      return extension;
     },
     updateExtension(root, args, ctx) {
       return ctx.registryExtensionService.updateExtensionName(args.extension, args.name);
     },
-    deleteExtension(root, args, ctx) {
-      return ctx.registryExtensionService.deleteExtension(args.extension);
-    },
-    async installExtension(root, args, ctx) {
-      const extension = await ctx.registryExtensionService.findExtension(args.extensionID);
-      if (!extension) {
-        throw new Error(`Extension ${args.extensionID} not found`);
-      }
-      return ctx.registryExtensionService.updateExtension(args.extensionID, {
-        installed: true
-      });
-    },
-    async uninstallExtension(root, args, ctx) {
-      const extension = await ctx.registryExtensionService.findExtension(args.extensionID);
-      if (!extension) {
-        throw new Error(`Extension ${args.extensionID} not found`);
-      }
-      return ctx.registryExtensionService.updateExtension(args.extensionID, {
-        installed: false
-      });
+    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
       });
       return {
-        extension
+        extension: extension
       };
     }
   }
-});export{resolver};//# sourceMappingURL=resolvers.js.map
+});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":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/graphql/schemas/extension-registry.graphql

@@ -0,0 +1,74 @@
+
+type ExtensionRelease @entity(embedded: true) {
+    id: ID @id
+    bundle: String @column
+    bundleURL: String @column
+    version: String @column
+    manifest: String! @column
+    sourceMap: String @column
+    extensionSlug: String @column
+    creatorUserId: String @column
+    releaseVersion: String @column
+}
+
+enum ExtensionStatus {
+    """The extension is active and available for use."""
+    ACTIVE
+
+    """The extension is inactive and not available for use."""
+    INACTIVE
+
+    """The extension is deprecated and should not be used."""
+    DEPRECATED
+}
+
+type RegistryExtension implements Node @entity {
+    """The unique, opaque, permanent ID of the extension."""
+    id: ID! @id
+
+    """The UUID of the extension. This identifies the extension externally (along with the origin). The UUID maps
+     1-t0-1 to RegistryExtension.id."""
+    uuid: String! @column
+
+    """ The publisher of the extension. If this extension is from a remote registry, the publisher may be null."""
+    publisher: RegistryPublisher
+
+    """ The qualified, unique name that refers to this extension, consisting of the registry name (if non-default),
+     publisher's name, and the extension's name, all joined by "/" (for example, "cdecode/my-extension-name")."""
+    extensionSlug: String @column
+
+    status: ExtensionStatus @column
+
+    """The extension ID without the registry name."""
+    extensionIDWithoutRegistry: String @column
+
+    """The name of the extension."""
+    name: String! @column
+
+    """Latest Published version."""
+    version: String
+
+    """The extension manifest."""
+    manifest: ExtensionManifest
+
+    """The date when this extension was last updated on the registry."""
+    updatedAt: DateTime @column(overrideType: "Date")
+
+    """The URL to the extension on this CDECode site."""
+    url: String @column
+
+    """The URL to the extension on the extension registry where it lives."""
+    remoteURL: String @column
+
+    """Whether the registry extension is published on this CDECode site."""
+    isLocal: Boolean @column
+
+    """Whether the viewer has admin privileges on this registry extension."""
+    viewerCanAdminister: Boolean @column
+
+    """Extension Releases."""
+    releases: [ExtensionRelease!] @embedded
+
+    """Whether the extension is installed."""
+    installed: Boolean
+}

package/lib/graphql/schemas/extension-registry.graphql.js

@@ -0,0 +1 @@
+var extensionRegistrySchema = "\ntype ExtensionRelease @entity(embedded: true) {\n    id: ID @id\n    bundle: String @column\n    bundleURL: String @column\n    version: String @column\n    manifest: String! @column\n    sourceMap: String @column\n    extensionSlug: String @column\n    creatorUserId: String @column\n    releaseVersion: String @column\n}\n\nenum ExtensionStatus {\n    \"\"\"The extension is active and available for use.\"\"\"\n    ACTIVE\n\n    \"\"\"The extension is inactive and not available for use.\"\"\"\n    INACTIVE\n\n    \"\"\"The extension is deprecated and should not be used.\"\"\"\n    DEPRECATED\n}\n\ntype RegistryExtension implements Node @entity {\n    \"\"\"The unique, opaque, permanent ID of the extension.\"\"\"\n    id: ID! @id\n\n    \"\"\"The UUID of the extension. This identifies the extension externally (along with the origin). The UUID maps\n     1-t0-1 to RegistryExtension.id.\"\"\"\n    uuid: String! @column\n\n    \"\"\" The publisher of the extension. If this extension is from a remote registry, the publisher may be null.\"\"\"\n    publisher: RegistryPublisher\n\n    \"\"\" The qualified, unique name that refers to this extension, consisting of the registry name (if non-default),\n     publisher's name, and the extension's name, all joined by \"/\" (for example, \"cdecode/my-extension-name\").\"\"\"\n    extensionSlug: String @column\n\n    status: ExtensionStatus @column\n\n    \"\"\"The extension ID without the registry name.\"\"\"\n    extensionIDWithoutRegistry: String @column\n\n    \"\"\"The name of the extension.\"\"\"\n    name: String! @column\n\n    \"\"\"Latest Published version.\"\"\"\n    version: String\n\n    \"\"\"The extension manifest.\"\"\"\n    manifest: ExtensionManifest\n\n    \"\"\"The date when this extension was last updated on the registry.\"\"\"\n    updatedAt: DateTime @column(overrideType: \"Date\")\n\n    \"\"\"The URL to the extension on this CDECode site.\"\"\"\n    url: String @column\n\n    \"\"\"The URL to the extension on the extension registry where it lives.\"\"\"\n    remoteURL: String @column\n\n    \"\"\"Whether the registry extension is published on this CDECode site.\"\"\"\n    isLocal: Boolean @column\n\n    \"\"\"Whether the viewer has admin privileges on this registry extension.\"\"\"\n    viewerCanAdminister: Boolean @column\n\n    \"\"\"Extension Releases.\"\"\"\n    releases: [ExtensionRelease!] @embedded\n\n    \"\"\"Whether the extension is installed.\"\"\"\n    installed: Boolean\n}\n";export{extensionRegistrySchema as default};//# sourceMappingURL=extension-registry.graphql.js.map

package/lib/graphql/schemas/extension-registry.graphql.js.map

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

package/lib/graphql/schemas/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/graphql/schemas/index.ts"],"names":[],"mappings":"AAGA,QAAA,MAAM,MAAM,QAGA,CAAC;AACb,OAAO,EAAE,MAAM,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/graphql/schemas/index.ts"],"names":[],"mappings":"AAIA,QAAA,MAAM,MAAM,QAAgF,CAAC;AAC7F,OAAO,EAAE,MAAM,EAAE,CAAC"}

package/lib/graphql/schemas/index.js

@@ -1,4 +1 @@
-import extensionSchema from'./extension.graphql.js';// import marketplaceSchema from './marketplace.graphql';
-const schema = [
-// marketplaceSchema,
-extensionSchema].join('\n');export{schema};//# sourceMappingURL=index.js.map
+import extensionRegistrySchema from'./extension-registry.graphql.js';import installedExtensionSchema from'./installed-extension.graphql.js';import serviceSchema from'./service.graphql.js';const schema = [extensionRegistrySchema, installedExtensionSchema, serviceSchema].join('\n');export{schema};//# sourceMappingURL=index.js.map

package/lib/graphql/schemas/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../../src/graphql/schemas/index.ts"],"sourcesContent":[null],"names":[],"mappings":"oDAOA;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}