@adminide-stack/marketplace-module-server 12.0.4-alpha.41 → 12.0.4-alpha.412

package/lib/utils/publisherValidation.js

@@ -0,0 +1,144 @@
+/**
+ * Backend validation utilities for publisher data
+ */
+/**
+ * Validates a publisher name on the backend
+ * Ensures it doesn't contain characters that would break URL routing or extension slug parsing
+ */
+function validatePublisherName(publisherName) {
+  if (!publisherName || publisherName.trim().length === 0) {
+    return {
+      valid: false,
+      error: 'Publisher name is required'
+    };
+  }
+  const trimmed = publisherName.trim();
+  // Check minimum length
+  if (trimmed.length < 2) {
+    return {
+      valid: false,
+      error: 'Publisher name must be at least 2 characters long'
+    };
+  }
+  // Check maximum length
+  if (trimmed.length > 50) {
+    return {
+      valid: false,
+      error: 'Publisher name must be less than 50 characters'
+    };
+  }
+  // Check for invalid characters that would break routing or parsing
+  if (trimmed.includes('/')) {
+    return {
+      valid: false,
+      error: 'Publisher name cannot contain forward slashes (/)'
+    };
+  }
+  if (trimmed.includes('.')) {
+    return {
+      valid: false,
+      error: 'Publisher name cannot contain dots (.)'
+    };
+  }
+  if (trimmed.includes('\\')) {
+    return {
+      valid: false,
+      error: 'Publisher name cannot contain backslashes (\\)'
+    };
+  }
+  // Check for other URL-unsafe characters
+  const urlUnsafeChars = ['?', '#', '&', '%', '+', '=', '<', '>', '"', '`', '{', '}', '|', '^', '[', ']', '@', ':', ';', ',', ' '];
+  for (const char of urlUnsafeChars) {
+    if (trimmed.includes(char)) {
+      return {
+        valid: false,
+        error: `Publisher name cannot contain the character: ${char}`
+      };
+    }
+  }
+  // Check if it starts or ends with special characters
+  if (trimmed.startsWith('-') || trimmed.endsWith('-')) {
+    return {
+      valid: false,
+      error: 'Publisher name cannot start or end with hyphens'
+    };
+  }
+  if (trimmed.startsWith('_') || trimmed.endsWith('_')) {
+    return {
+      valid: false,
+      error: 'Publisher name cannot start or end with underscores'
+    };
+  }
+  // Only allow alphanumeric characters, hyphens, and underscores
+  const validPattern = /^[a-zA-Z0-9]([a-zA-Z0-9_-]*[a-zA-Z0-9])?$/;
+  if (!validPattern.test(trimmed)) {
+    return {
+      valid: false,
+      error: 'Publisher name can only contain letters, numbers, hyphens, and underscores'
+    };
+  }
+  return {
+    valid: true
+  };
+}
+/**
+ * Validates publisher data for creation or update
+ */
+function validatePublisherData(data) {
+  // Validate publisher name
+  const nameValidation = validatePublisherName(data.publisherName);
+  if (!nameValidation.valid) {
+    return nameValidation;
+  }
+  // Validate display name
+  if (!data.displayName || data.displayName.trim().length === 0) {
+    return {
+      valid: false,
+      error: 'Display name is required'
+    };
+  }
+  if (data.displayName.trim().length > 100) {
+    return {
+      valid: false,
+      error: 'Display name must be less than 100 characters'
+    };
+  }
+  // Validate email if provided
+  if (data.email && data.email.trim().length > 0) {
+    const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    if (!emailPattern.test(data.email)) {
+      return {
+        valid: false,
+        error: 'Please provide a valid email address'
+      };
+    }
+  }
+  // Validate website if provided
+  if (data.website && data.website.trim().length > 0) {
+    try {
+      const url = new URL(data.website);
+      // URL constructor validates the URL format
+      if (!url.protocol.startsWith('http')) {
+        return {
+          valid: false,
+          error: 'Website must use http or https protocol'
+        };
+      }
+    } catch {
+      return {
+        valid: false,
+        error: 'Website must be a valid URL'
+      };
+    }
+  }
+  // Validate description length if provided
+  if (data.description && data.description.length > 1000) {
+    return {
+      valid: false,
+      error: 'Description must be less than 1000 characters'
+    };
+  }
+  return {
+    valid: true
+  };
+}export{validatePublisherData,validatePublisherName};//# sourceMappingURL=publisherValidation.js.map

package/lib/utils/publisherValidation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"publisherValidation.js","sources":["../../src/utils/publisherValidation.ts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;;AAEG;AAEH;;;AAGC;AAED,SAAA,qBAAA,CAAA,aAAA,EAAA;;;AAGG,MAAA,KAAA,EAAA,KAAA;AACH,MAAA,KAAA,EAAA;AA8EA,KAAA;;AAEG,EAAA,MAAA,OAAA,GAAA,aAAA,CAAA,IAAA,EAAA;AACH;MACI,OAAA,CAAA,YAAsB;IACtB,OAAA;MACA,KAAM,EAAE,KAAM;MACd,KAAO,EAAC;KACR;AACH,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@adminide-stack/marketplace-module-server",
-    "version": "12.0.4-alpha.41",
+    "version": "12.0.4-alpha.412",
     "description": "Sample core for higher packages to depend on",
     "license": "UNLICENSED",
     "author": "CDMBase LLC",
@@ -21,11 +21,11 @@
         "watch": "yarn build:lib:watch"
     },
     "dependencies": {
-        "@adminide-stack/extension-api": "12.0.4-alpha.41",
+        "@adminide-stack/extension-api": "12.0.4-alpha.412",
         "nanoid": "^5.1.5"
     },
     "devDependencies": {
-        "common": "12.0.4-alpha.41"
+        "common": "12.0.4-alpha.412"
     },
     "peerDependencies": {
         "graphql-tag": ">=2.0.0"
@@ -36,18 +36,26 @@
     "cdecode": {
         "common": {
             "constants": [
-                "./${libDir}/templates/constants/SERVER_TYPES.ts.template"
+                "./${libDir}/templates/constants/SERVER_TYPES.ts.template",
+                "./${libDir}/templates/constants/DB_COLL_NAMES.ts.template"
             ],
             "services": [
-                "./${libDir}/templates/services/RegistryExtensionService.ts.template"
+                "./${libDir}/templates/services/InstalledExtensionService.ts.template",
+                "./${libDir}/templates/services/InstalledExtensionDataLoader.ts.template",
+                "./${libDir}/templates/services/MarketplacePublisherService.ts.template",
+                "./${libDir}/templates/services/PublisherEventService.ts.template",
+                "./${libDir}/templates/services/ExtensionGalleryService.ts.template",
+                "./${libDir}/templates/services/ExtensionGalleryDataLoader.ts.template"
             ],
             "repositories": [
-                "./${libDir}/templates/repositories/RegistryExtensionRepository.ts.template"
+                "./${libDir}/templates/repositories/InstalledExtensionRepository.ts.template",
+                "./${libDir}/templates/repositories/MarketplacePublisherRepository.ts.template",
+                "./${libDir}/templates/repositories/ExtensionGalleryRepository.ts.template"
             ]
         }
     },
     "typescript": {
         "definition": "lib/index.d.ts"
     },
-    "gitHead": "809abd185e95a481afc96faa1212072162c169e6"
+    "gitHead": "49ebdad1366ea930ec9f66b1ef7e0398f32fb314"
 }

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

@@ -1,2 +0,0 @@
-export declare const resolver: any;
-//# sourceMappingURL=resolvers.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"resolvers.d.ts","sourceRoot":"","sources":["../../../src/graphql/resolvers/resolvers.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,QAAQ,EAAE,GAuMrB,CAAC"}

package/lib/graphql/resolvers/resolvers.js

@@ -1,167 +0,0 @@
-import*as url from'url';const bundleUrlGenerator = (extensionID, version) => url.resolve(process.env.BACKEND_URL, `_registry/${extensionID}/${version}`);
-const resolver = (pubsub, logger) => ({
-  Contributes: {
-    menus: root => {
-      let result;
-      // const manifest = JSON.parse(root.manifest);
-      // console.log('manifest======>', manifest);
-      const menus = root.menus;
-      console.log('menus=========>', menus);
-      try {
-        result = {
-          commandPalette: menus['commandPalette'] || [],
-          explorer: {
-            context: menus['explorer/context'] || []
-          },
-          editor: {
-            context: menus['editor/context'] || [],
-            title: {
-              own: menus['editor/title'] || [],
-              context: menus['editor/title/context'] || []
-            }
-          },
-          debug: {
-            callstack: {
-              context: menus['debug/callstack/context'] || []
-            },
-            toolbar: menus['debug/toolbar'] || []
-          },
-          scm: {
-            title: menus['scm/title'] || [],
-            resourceGroup: {
-              context: menus['scm/resourceGroup/context'] || []
-            },
-            resource: {
-              context: menus['scm/resource/context'] || []
-            },
-            change: {
-              title: menus['scm/change/title'] || []
-            }
-          },
-          view: {
-            title: menus['view/title'] || [],
-            item: {
-              context: menus['view/item/context'] || []
-            }
-          },
-          touchBar: menus['touchBar'] || []
-        };
-      } catch (err) {
-        console.log('err', err);
-      }
-      console.log('result====>', result, result.editor);
-      return result;
-    }
-  },
-  ExtensionRegistry: {
-    async extensions(root, args, ctx) {
-      logger && logger.debug('args [%j]', args);
-      const nodes = await ctx.registryExtensionService.findExtensions(args.first, args.query, args.local, args.remote, args.prioritizeExtensionIDs);
-      return {
-        nodes
-      };
-    },
-    async extension(root, args, ctx) {
-      return ctx.registryExtensionService.findExtension(args.extensionID);
-    },
-    async releases(root, args, ctx) {
-      return ctx.registryExtensionService.extensionReleases(args.extensionID);
-    },
-    async publishers(root, args, ctx) {},
-    async viewerPublishers(root, args, ctx) {},
-    async localExtensionIDPrefix(root, args, ctx) {}
-  },
-  ExtensionRelease: {
-    bundleURL: root => bundleUrlGenerator(root.extensionID, root.version)
-  },
-  ExtensionManifest: {
-    bundleURL: ({
-      version,
-      extensionID
-    }) => bundleUrlGenerator(extensionID, version)
-  },
-  RegistryExtension: {
-    manifest: root => {
-      let result;
-      // console.log('root=================>', JSON.parse(root.manifest));
-      try {
-        result = {
-          ...JSON.parse(root.manifest),
-          extensionID: root.extensionID,
-          raw: root.manifest
-        };
-      } catch (err) {}
-      return result;
-    },
-    url: root => bundleUrlGenerator(root.extensionID, root.version)
-  },
-  Query: {
-    // namespace for running all extension registry queries
-    extensionRegistry() {
-      return {};
-    },
-    /// 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 res = { nodes: {...nodes, manifest: JSON.parse(nodes[0].manifest)} };
-      // console.log('nodes==>', nodes);
-      //  nodes = nodes.map(el => {
-      //    return {
-      //      ...JSON.parse(JSON.stringify(el)),
-      //      manifest: JSON.parse(el.manifest),
-      //    };
-      //  });
-      //   console.log('nodes=======after>', nodes);
-      return {
-        nodes
-      };
-    },
-    async extension(root, args, ctx) {
-      return ctx.registryExtensionService.findExtension(args.extensionID);
-    },
-    async releases(root, args, ctx) {
-      return ctx.registryExtensionService.extensionReleases(args.extensionID);
-    }
-  },
-  Mutation: {
-    async createExtension(root, args, ctx) {
-      const extension = await ctx.registryExtensionService.createExtension(args.publisher, args.name);
-      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 publishExtension(root, args, ctx) {
-      const extension = await ctx.registryExtensionService.publishExtension({
-        ...args
-      });
-      return {
-        extension
-      };
-    }
-  }
-});export{resolver};//# sourceMappingURL=resolvers.js.map

package/lib/graphql/resolvers/resolvers.js.map

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

package/lib/graphql/schemas/extension.graphql

@@ -1,57 +0,0 @@
-extend type Mutation {
-    """Install an extension in the registry."""
-    installExtension(extensionID: String!): RegistryExtension!
-
-    """Uninstall an extension from the registry."""
-    uninstallExtension(extensionID: String!): RegistryExtension!
-}
-
-type RegistryExtension implements Node {
-    """The unique, opaque, permanent ID of the extension."""
-    id: ID!
-
-    """The UUID of the extension."""
-    uuid: String!
-
-    """The publisher of the extension."""
-    publisher: RegistryPublisher
-
-    """The qualified, unique name that refers to this extension."""
-    extensionID: String
-
-    """The extension ID without the registry name."""
-    extensionIDWithoutRegistry: String
-
-    """The name of the extension."""
-    name: String!
-
-    """Latest Published version."""
-    version: String
-
-    """The activation events for this extension."""
-    activationEvents: [String!]
-
-    """The extension manifest."""
-    manifest: ExtensionManifest
-
-    """The date when this extension was last updated on the registry."""
-    updatedAt: String
-
-    """The URL to the extension on this CDECode site."""
-    url: String
-
-    """The URL to the extension on the extension registry where it lives."""
-    remoteURL: String
-
-    """Whether the registry extension is published on this CDECode site."""
-    isLocal: Boolean
-
-    """Whether the viewer has admin privileges on this registry extension."""
-    viewerCanAdminister: Boolean
-
-    """Extension Releases."""
-    releases: [ExtensionRelease!]
-
-    """Whether the extension is installed."""
-    installed: Boolean
-}

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

@@ -1 +0,0 @@
-var extensionSchema = "extend type Mutation {\n    \"\"\"Install an extension in the registry.\"\"\"\n    installExtension(extensionID: String!): RegistryExtension!\n\n    \"\"\"Uninstall an extension from the registry.\"\"\"\n    uninstallExtension(extensionID: String!): RegistryExtension!\n}\n\ntype RegistryExtension implements Node {\n    \"\"\"The unique, opaque, permanent ID of the extension.\"\"\"\n    id: ID!\n\n    \"\"\"The UUID of the extension.\"\"\"\n    uuid: String!\n\n    \"\"\"The publisher of the extension.\"\"\"\n    publisher: RegistryPublisher\n\n    \"\"\"The qualified, unique name that refers to this extension.\"\"\"\n    extensionID: String\n\n    \"\"\"The extension ID without the registry name.\"\"\"\n    extensionIDWithoutRegistry: String\n\n    \"\"\"The name of the extension.\"\"\"\n    name: String!\n\n    \"\"\"Latest Published version.\"\"\"\n    version: String\n\n    \"\"\"The activation events for this extension.\"\"\"\n    activationEvents: [String!]\n\n    \"\"\"The extension manifest.\"\"\"\n    manifest: ExtensionManifest\n\n    \"\"\"The date when this extension was last updated on the registry.\"\"\"\n    updatedAt: String\n\n    \"\"\"The URL to the extension on this CDECode site.\"\"\"\n    url: String\n\n    \"\"\"The URL to the extension on the extension registry where it lives.\"\"\"\n    remoteURL: String\n\n    \"\"\"Whether the registry extension is published on this CDECode site.\"\"\"\n    isLocal: Boolean\n\n    \"\"\"Whether the viewer has admin privileges on this registry extension.\"\"\"\n    viewerCanAdminister: Boolean\n\n    \"\"\"Extension Releases.\"\"\"\n    releases: [ExtensionRelease!]\n\n    \"\"\"Whether the extension is installed.\"\"\"\n    installed: Boolean\n}\n";export{extensionSchema as default};//# sourceMappingURL=extension.graphql.js.map

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

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

package/lib/services/extension-service.d.ts

@@ -1,54 +0,0 @@
-import { CdmLogger } from '@cdm-logger/core';
-import { IRegistryExtensionService, IRegistryExtensionRepository } from 'common/server';
-export declare class RegistryExtensionService implements IRegistryExtensionService {
-    private extensionRepository;
-    private logger;
-    constructor(extensionRepository: IRegistryExtensionRepository, logger: CdmLogger.ILogger);
-    createExtension(publisherId: string, name: string): Promise<import("common").INode & {
-        __typename?: "RegistryExtension";
-        activationEvents?: import("common").Maybe<Array<import("common").Maybe<import("common").Scalars["String"]["output"]>>>;
-        extensionID?: import("common").Maybe<import("common").Scalars["String"]["output"]>;
-        extensionIDWithoutRegistry?: import("common").Maybe<import("common").Scalars["String"]["output"]>;
-        id: import("common").Scalars["ID"]["output"];
-        installed?: import("common").Maybe<import("common").Scalars["Boolean"]["output"]>;
-        isLocal?: import("common").Maybe<import("common").Scalars["Boolean"]["output"]>;
-        manifest?: import("common").Maybe<import("common").IExtensionManifest>;
-        name: import("common").Scalars["String"]["output"];
-        publisher?: import("common").Maybe<import("common").IRegistryPublisher>;
-        releases?: import("common").Maybe<Array<import("common").Maybe<import("common").IExtensionRelease>>>;
-        remoteURL?: import("common").Maybe<import("common").Scalars["String"]["output"]>;
-        updatedAt?: import("common").Maybe<import("common").Scalars["String"]["output"]>;
-        url?: import("common").Maybe<import("common").Scalars["String"]["output"]>;
-        uuid: import("common").Scalars["String"]["output"];
-        version?: import("common").Maybe<import("common").Scalars["String"]["output"]>;
-        viewerCanAdminister?: import("common").Maybe<import("common").Scalars["Boolean"]["output"]>;
-    } & import("common/server").IRepositoryDefault>;
-    updateExtensionName(extensionID: string, name: string): Promise<any>;
-    updateExtension(extensionID: string, update: {
-        installed?: boolean;
-    }): Promise<import("common").INode & {
-        __typename?: "RegistryExtension";
-        activationEvents?: import("common").Maybe<Array<import("common").Maybe<import("common").Scalars["String"]["output"]>>>;
-        extensionID?: import("common").Maybe<import("common").Scalars["String"]["output"]>;
-        extensionIDWithoutRegistry?: import("common").Maybe<import("common").Scalars["String"]["output"]>;
-        id: import("common").Scalars["ID"]["output"];
-        installed?: import("common").Maybe<import("common").Scalars["Boolean"]["output"]>;
-        isLocal?: import("common").Maybe<import("common").Scalars["Boolean"]["output"]>;
-        manifest?: import("common").Maybe<import("common").IExtensionManifest>;
-        name: import("common").Scalars["String"]["output"];
-        publisher?: import("common").Maybe<import("common").IRegistryPublisher>;
-        releases?: import("common").Maybe<Array<import("common").Maybe<import("common").IExtensionRelease>>>;
-        remoteURL?: import("common").Maybe<import("common").Scalars["String"]["output"]>;
-        updatedAt?: import("common").Maybe<import("common").Scalars["String"]["output"]>;
-        url?: import("common").Maybe<import("common").Scalars["String"]["output"]>;
-        uuid: import("common").Scalars["String"]["output"];
-        version?: import("common").Maybe<import("common").Scalars["String"]["output"]>;
-        viewerCanAdminister?: import("common").Maybe<import("common").Scalars["Boolean"]["output"]>;
-    } & import("common/server").IRepositoryDefault>;
-    extensionReleases(extensionID: string): Promise<import("common").IExtensionRelease[]>;
-    deleteExtension(extensionID: string): Promise<boolean>;
-    publishExtension(request: any): Promise<any>;
-    findExtensions(first: number, query: string, local?: boolean, remote?: boolean, prioritizeExtensionIDs?: string[]): Promise<any>;
-    findExtension(extensionID: string): Promise<any>;
-}
-//# sourceMappingURL=extension-service.d.ts.map

package/lib/services/extension-service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"extension-service.d.ts","sourceRoot":"","sources":["../../src/services/extension-service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAgB,yBAAyB,EAAE,4BAA4B,EAAE,MAAM,eAAe,CAAC;AAEtG,qBACa,wBAAyB,YAAW,yBAAyB;IAKlE,OAAO,CAAC,mBAAmB;IAJ/B,OAAO,CAAC,MAAM,CAAoB;gBAItB,mBAAmB,EAAE,4BAA4B,EAGzD,MAAM,EAAE,SAAS,CAAC,OAAO;IAKhB,eAAe,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;;+EA4Cw4ta,kCAAiB;6CAA4G,kCAAiB;4DAA2G,kCAAiB;YAAkF,8BAAc;2CAAiF,mCAAkB;yCAA8G,mCAAkB;;cAAyI,kCAAkB;;;2CAA4R,kCAAiB;2CAA6G,kCAAiB;qCAAuF,kCAAiB;cAA4D,kCAAkB;yCAAqE,kCAAiB;qDAA4H,mCAAkB;;IAxCt+wa,mBAAmB,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IAIrD,eAAe,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE;;+EAoCq3ta,kCAAiB;6CAA4G,kCAAiB;4DAA2G,kCAAiB;YAAkF,8BAAc;2CAAiF,mCAAkB;yCAA8G,mCAAkB;;cAAyI,kCAAkB;;;2CAA4R,kCAAiB;2CAA6G,kCAAiB;qCAAuF,kCAAiB;cAA4D,kCAAkB;yCAAqE,kCAAiB;qDAA4H,mCAAkB;;IA3Bt+wa,iBAAiB,CAAC,WAAW,EAAE,MAAM;IAKrC,eAAe,CAAC,WAAW,EAAE,MAAM;IAInC,gBAAgB,CAAC,OAAO,KAAA;IAIxB,cAAc,CACvB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,KAAK,CAAC,EAAE,OAAO,EACf,MAAM,CAAC,EAAE,OAAO,EAChB,sBAAsB,CAAC,EAAE,MAAM,EAAE;IAKxB,aAAa,CAAC,WAAW,EAAE,MAAM;CAGjD"}

package/lib/services/extension-service.js

@@ -1,42 +0,0 @@
-import {__decorate,__param,__metadata}from'tslib';import {injectable,inject}from'inversify';import'@cdm-logger/core';import {SERVER_TYPES}from'common/server';var RegistryExtensionService_1;
-let RegistryExtensionService = RegistryExtensionService_1 = class RegistryExtensionService {
-  extensionRepository;
-  logger;
-  constructor(extensionRepository, logger) {
-    this.extensionRepository = extensionRepository;
-    this.logger = logger.child({
-      className: RegistryExtensionService_1.name
-    });
-  }
-  async createExtension(publisherId, name) {
-    return this.extensionRepository.createExtension(publisherId, name);
-  }
-  async updateExtensionName(extensionID, name) {
-    return this.extensionRepository.updateExtensionName(extensionID, name);
-  }
-  async updateExtension(extensionID, update) {
-    const extension = await this.findExtension(extensionID);
-    if (!extension) {
-      throw new Error(`Extension ${extensionID} not found`);
-    }
-    return this.extensionRepository.updateExtension(extensionID, update);
-  }
-  // TODO: Add method to interface
-  async extensionReleases(extensionID) {
-    this.logger.debug(`Fetching releases for ${extensionID}`);
-    return this.extensionRepository.extensionReleases(extensionID);
-  }
-  async deleteExtension(extensionID) {
-    return this.extensionRepository.deleteExtension(extensionID);
-  }
-  async publishExtension(request) {
-    return this.extensionRepository.publishExtension(request);
-  }
-  async findExtensions(first, query, local, remote, prioritizeExtensionIDs) {
-    return this.extensionRepository.findExtensions(first, query, local, remote, prioritizeExtensionIDs);
-  }
-  async findExtension(extensionID) {
-    return this.extensionRepository.findExtension(extensionID);
-  }
-};
-RegistryExtensionService = RegistryExtensionService_1 = __decorate([injectable(), __param(0, inject(SERVER_TYPES.IRegistryExtensionRepository)), __param(1, inject('Logger')), __metadata("design:paramtypes", [Object, Object])], RegistryExtensionService);export{RegistryExtensionService};//# sourceMappingURL=extension-service.js.map

package/lib/services/extension-service.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"extension-service.js","sources":["../../src/services/extension-service.ts"],"sourcesContent":[null],"names":[],"mappings":"8JACA,IAAA;AASgB,IAAA,wBAAA,GAAA,0BAAiD,GAAA,MAAA,wBAGhC,CAAA;AAKhB,EAAA,mBAA2B;;;kDA4C4iua;;eAA4N,EAAA,0BAAA,CAAA;;;;eAA8X,CAAA,mBAAA,CAAA,eAAA,CAAA,WAAA,EAAA,IAAA,CAAA;;;uDAA6S,CAAA,WAAA,EAAA,IAAA,CAAA;;qCAAqN,MAAiB,EAAA;mBAA8E,GAAA,MAAA,IAAA,CAAA,aAAA,CAAA,WAAA,CAAA;;yDAAoO,CAAA,CAAA;;AAxCt+wa,IAAA,OAAA,IAAA,CAAA,mBAA+B,CAAA,eAAgB,CAAM,WAAA,EAAA,MAAA,CAAA;AAIrD;;AAAoE,EAAA,MAAA,iBAAA,CAAA,WAAA,EAAA;;;;;eAoC+tua,CAAA,mBAAA,CAAA,eAAA,CAAA,WAAA,CAAA;;;;;;;;;iDAAi5B,CAAA,WAAA,CAAA;;;qDAAgS,GAAkB,UAAA,CAAA,CAAA,UAAA,EAAA,EAAA,OAAA,CAAA,CAAA,EAAA,MAAA,CAAA,YAAA,CAAA,4BAAA,CAAA,CAAA,EAAA,OAAA,CAAA,CAAA,EAAA,MAAA,CAAA,QAAA,CAAA,CAAA,EAAA,UAAA,CAAA,mBAAA,EAAA,CAAA,MAAA,EAAA,MAAA,CAAA,CAAA,CAAA,EAAA,wBAAA,CAAA"}

package/lib/store/models/registry-extension-model.d.ts

@@ -1,10 +0,0 @@
-import { Model, Document, Connection } from 'mongoose';
-import { IRegistryExtension as IRegistryExtensionRecord } from 'common/server';
-export interface IRegistryExtensionModel extends Document, IRegistryExtensionRecord {
-    id: any;
-    type: string;
-    publisherId: string;
-}
-export type RegistryExtensionModelType = Model<IRegistryExtensionModel>;
-export declare const RegistryExtensionModelFunc: (db: Connection) => RegistryExtensionModelType;
-//# sourceMappingURL=registry-extension-model.d.ts.map

package/lib/store/models/registry-extension-model.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"registry-extension-model.d.ts","sourceRoot":"","sources":["../../../src/store/models/registry-extension-model.ts"],"names":[],"mappings":"AACA,OAAO,EAAU,KAAK,EAAE,QAAQ,EAAY,UAAU,EAAE,MAAM,UAAU,CAAC;AACzE,OAAO,EAAE,kBAAkB,IAAI,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAG/E,MAAM,WAAW,uBAAwB,SAAQ,QAAQ,EAAE,wBAAwB;IAC/E,EAAE,EAAE,GAAG,CAAC;IACR,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;CACvB;AAuDD,MAAM,MAAM,0BAA0B,GAAG,KAAK,CAAC,uBAAuB,CAAC,CAAC;AACxE,eAAO,MAAM,0BAA0B,EAAE,CAAC,EAAE,EAAE,UAAU,KAAK,0BACc,CAAC"}

package/lib/store/models/registry-extension-model.js

@@ -1,62 +0,0 @@
-import {find}from'lodash-es';import {Schema}from'mongoose';import {customAlphabet}from'nanoid';const createRandom = customAlphabet('0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', 15);
-const RegistryExtensionReleaseSchema = new Schema({
-  creatorUserId: {
-    type: String
-  },
-  releaseVersion: {
-    type: String
-  },
-  extensionID: String,
-  activationEvents: [String],
-  type: String,
-  manifest: {
-    type: String
-  },
-  version: {
-    type: String
-  },
-  bundle: {
-    type: String
-  },
-  sourceMap: {
-    type: String
-  }
-}, {
-  strict: false
-});
-const RegistryExtensionSchema = new Schema({
-  type: String,
-  version: String,
-  extensionID: String,
-  publisherId: String,
-  activationEvents: [String],
-  uuid: {
-    type: String,
-    default: () => createRandom()
-  },
-  name: {
-    type: String,
-    default: () => createRandom()
-  },
-  releases: [{
-    type: RegistryExtensionReleaseSchema
-  }]
-}, {
-  strict: false
-});
-RegistryExtensionSchema.virtual('manifest').get(function () {
-  const release = find(this.releases, {
-    version: this.version
-  });
-  return release.manifest || {};
-});
-RegistryExtensionSchema.virtual('id').get(function () {
-  return this._id.toHexString();
-});
-RegistryExtensionSchema.set('toJSON', {
-  virtuals: true
-});
-RegistryExtensionSchema.set('toObject', {
-  virtuals: true
-});
-const RegistryExtensionModelFunc = db => db.model('extension', RegistryExtensionSchema);export{RegistryExtensionModelFunc};//# sourceMappingURL=registry-extension-model.js.map

package/lib/store/models/registry-extension-model.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"registry-extension-model.js","sources":["../../../src/store/models/registry-extension-model.ts"],"sourcesContent":[null],"names":[],"mappings":"qGAMM,YAAM,GAAA,cAAA,CAAA,gEAAA,EAAA,EAAA,CAAA;MACJ,8BAAS,GAAA,IAAA,MAAA,CAAA;eACF,EAAE;AAChB,IAAA,IAAA,EAAA;AAuDD,GAAA;AACA,EAAO,cAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/store/repository/index.d.ts

@@ -1,2 +0,0 @@
-export * from './registry-extension-repository';
-//# sourceMappingURL=index.d.ts.map

package/lib/store/repository/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/store/repository/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC"}