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

package/lib/templates/repositories/InstalledExtensionRepository.ts.template

@@ -0,0 +1,99 @@
+import { IBaseMongoRepository, IInstalledExtensionModel, AsDomainType } from 'common/server';
+import {
+    ICreateInstalledExtensionInput,
+    IUpdateInstalledExtensionInput,
+    IInstalledExtensionFilter,
+} from '../services/InstalledExtensionService';
+
+/**
+ * Repository interface for installed extensions data access layer
+ */
+export interface IInstalledExtensionRepository extends IBaseMongoRepository<IInstalledExtensionModel> {
+    /**
+     * Create a new installed extension record
+     */
+    create<T = ICreateInstalledExtensionInput>(data: T): Promise<AsDomainType<IInstalledExtensionModel>>;
+
+    /**
+     * Update an existing installed extension
+     */
+    updateExtension(
+        orgId: string,
+        extensionId: string,
+        update: IUpdateInstalledExtensionInput,
+    ): Promise<AsDomainType<IInstalledExtensionModel> | null>;
+
+    /**
+     * Find a specific installed extension by organization and extension ObjectIds
+     */
+    findByOrgAndExtensionId(orgId: string, extensionId: string): Promise<AsDomainType<IInstalledExtensionModel> | null>;
+
+    /**
+     * Find installed extensions with optional filtering
+     */
+    findExtensions(filter: IInstalledExtensionFilter): Promise<AsDomainType<IInstalledExtensionModel>[]>;
+
+    /**
+     * Find all installed extensions for a specific extension ObjectId
+     */
+    findByExtensionId(extensionId: string): Promise<AsDomainType<IInstalledExtensionModel>[]>;
+
+    /**
+     * Delete an installed extension
+     */
+    deleteExtension(orgId: string, extensionId: string): Promise<boolean>;
+
+    /**
+     * Get installed extensions joined with registry information
+     */
+    findWithRegistryInfo(filter: IInstalledExtensionFilter): Promise<any[]>;
+
+    /**
+     * Check if extension exists for organization
+     */
+    exists(orgId: string, extensionId: string): Promise<boolean>;
+
+    /**
+     * Bulk update multiple extensions (useful for policy changes or admin actions)
+     */
+    bulkUpdateExtensions(
+        orgId: string,
+        filter: Partial<IInstalledExtensionFilter>,
+        update: Partial<IUpdateInstalledExtensionInput>,
+    ): Promise<number>;
+
+    /**
+     * Get extension dependency graph for an organization
+     */
+    getDependencyGraph(orgId: string): Promise<{
+        extensions: AsDomainType<IInstalledExtensionModel>[];
+        dependencies: Array<{
+            extensionId: string;
+            dependsOn: string[];
+            dependents: string[];
+        }>;
+    }>;
+
+    /**
+     * Count installed extensions matching filter
+     */
+    countExtensions(filter: IInstalledExtensionFilter): Promise<number>;
+
+    /**
+     * Find extensions that need registry sync (stale registry status)
+     */
+    findStaleExtensions(orgId: string, maxAge: number): Promise<AsDomainType<IInstalledExtensionModel>[]>;
+
+    /**
+     * Update registry status for multiple extensions
+     */
+    syncRegistryStatus(
+        updates: Array<{
+            orgId: string;
+            extensionId: string;
+            registryStatus: string;
+            latestVersion?: string;
+            isOrphaned: boolean;
+        }>,
+    ): Promise<void>;
+}

package/lib/templates/repositories/MarketplacePublisherRepository.ts.template

@@ -0,0 +1,24 @@
+import { IBaseMongoRepository, IMarketplacePublisherModel, AsDomainType } from 'common/server';
+
+export interface IMarketplacePublisherRepository extends IBaseMongoRepository<IMarketplacePublisherModel> {
+    findByPublisherName(publisherName: string): Promise<AsDomainType<IMarketplacePublisherModel> | null>;
+    findPublishers(
+        search?: string,
+        orderBy?: string,
+        orderDirection?: 'ASC' | 'DESC',
+        limit?: number,
+        offset?: number,
+    ): Promise<{
+        publishers: AsDomainType<IMarketplacePublisherModel>[];
+        totalCount: number;
+    }>;
+    updatePublisherStats(
+        publisherId: string,
+        stats: {
+            extensionCount?: number;
+            totalInstalls?: number;
+            averageRating?: number;
+        },
+    ): Promise<AsDomainType<IMarketplacePublisherModel> | null>;
+    verifyPublisher(publisherId: string): Promise<AsDomainType<IMarketplacePublisherModel> | null>;
+}

package/lib/templates/repositories/RegistryExtensionRepository.ts.template

@@ -1,24 +1,19 @@
-import { IPublishRequest, IExtensionRelease, IRegistryExtension } from 'common/server';
+import { IMarketplacePublishExtensionInput, IExtensionRelease, IBaseMongoRepository, IRegistryExtensionModel, IExtensionReleaseModel, AsDomainType } from 'common/server';
 
-export interface IRepositoryDefault {
-    updatedAt?: string;
-    createdAt?: string;
-}
-
-export interface IRegistryExtensionRepository {
-    extensionReleases(extensionID: string): Promise<IExtensionRelease[]>;
+export interface IRegistryExtensionRepository extends IBaseMongoRepository<IRegistryExtensionModel> {
+    extensionReleases(extensionSlug: string): Promise<AsDomainType<IExtensionReleaseModel>[]>;
 
-    createExtension(publisherId: string, name: string): Promise<IRegistryExtension & IRepositoryDefault>;
+    createExtension(publisherId: string, name: string): Promise<AsDomainType<IRegistryExtensionModel>>;
 
-    updateExtensionName(extensionID: string, name: string);
+    updateExtensionName(extensionSlug: string, name: string): Promise<AsDomainType<IRegistryExtensionModel>>;
 
-    updateExtension(extensionID: string, update: { installed?: boolean }): Promise<IRegistryExtension & IRepositoryDefault>;
+    updateExtension(extensionSlug: string, update: { installed?: boolean }): Promise<AsDomainType<IRegistryExtensionModel>>;
 
-    deleteExtension(extensionID: string): boolean | Promise<boolean>;
+    deleteExtension(extensionSlug: string): boolean | Promise<boolean>;
 
-    publishExtension(request: IPublishRequest);
+    publishExtension(request: IMarketplacePublishExtensionInput): Promise<AsDomainType<IRegistryExtensionModel>>;
 
-    findExtensions(first: number, query: string, local?: boolean, remote?: boolean, prioritizeExtensionIDs?: string[]);
+    findExtensions(first: number, query: string, local?: boolean, remote?: boolean, prioritizeExtensionIDs?: string[]): Promise<AsDomainType<IRegistryExtensionModel>[]>;
 
-    findExtension(extensionID: string);
+    findExtension(extensionSlug: string): Promise<AsDomainType<IRegistryExtensionModel>>;
 }

package/lib/templates/services/ExtensionGalleryDataLoader.ts.template

@@ -0,0 +1,2 @@
+import { IGalleryExtension, IDataLoader } from 'common/server';
+export type IExtensionGalleryDataLoader = IDataLoader<IGalleryExtension>;

package/lib/templates/services/ExtensionGalleryService.ts.template

@@ -0,0 +1,79 @@
+// from package: marketplace-server
+import {
+    IGalleryExtension,
+    IExtensionIdentifier,
+    IExtensionManifest,
+    IGalleryPager,
+    AsDomainType,
+    IRegistryExtensionModel,
+} from 'common/server';
+
+/**
+ * Query options interface for gallery searches
+ */
+export interface IQueryOptions {
+    text?: string;
+    pageSize?: number;
+}
+
+/**
+ * Service interface for managing extension gallery
+ * IMPORTANT: All service methods that return domain entities MUST use AsDomainType<IEntityModel>
+ * This ensures proper type compatibility between MongoDB models and GraphQL domain types
+ */
+export interface IExtensionGalleryService {
+    /**
+     * Check if gallery service is enabled
+     */
+    isEnabled(): boolean;
+
+    /**
+     * Query extensions in gallery
+     */
+    query(options?: IQueryOptions): Promise<IGalleryPager>;
+
+    /**
+     * Get a specific extension by identifier
+     */
+    getExtension(identifier: IExtensionIdentifier | string): Promise<IGalleryExtension | null>;
+
+    /**
+     * Download an extension
+     */
+    download(extension: IGalleryExtension): Promise<string>;
+
+    /**
+     * Get extension README content
+     */
+    getReadme(extension: IGalleryExtension): Promise<string>;
+
+    /**
+     * Get extension manifest
+     */
+    getManifest(extension: IGalleryExtension): Promise<IExtensionManifest | null>;
+
+    /**
+     * Get extension changelog
+     */
+    getChangelog(extension: IGalleryExtension): Promise<string>;
+
+    /**
+     * Get extension license
+     */
+    getLicense(extension: IGalleryExtension): Promise<string>;
+
+    /**
+     * Load compatible version of extension
+     */
+    loadCompatibleVersion(extension: IGalleryExtension): Promise<IGalleryExtension>;
+}
+
+/**
+ * This file augments the ServerContext interface from the central apollo-context.
+ * Through declaration merging, the extensionGalleryService will be added to the ServerContext.
+ */
+declare module '../apollo-context' {
+    export interface ServerContext {
+        extensionGalleryService: IExtensionGalleryService;
+    }
+}

package/lib/templates/services/InstalledExtensionDataLoader.ts.template

@@ -0,0 +1,2 @@
+import { IInstalledExtension, IDataLoader } from 'common/server';
+export type IInstalledExtensionDataLoader = IDataLoader<IInstalledExtension>;

package/lib/templates/services/InstalledExtensionService.ts.template

@@ -0,0 +1,199 @@
+import {
+    IInstalledExtensionModel,
+    IInstallExtensionInput,
+    IExtensionPoliciesInput,
+    IExtensionSettingsInput,
+    AsDomainType,
+    IBaseService,
+} from 'common/server';
+
+/**
+ * Input type for creating installed extensions with additional server-side fields
+ */
+export interface ICreateInstalledExtensionInput extends IInstallExtensionInput {
+    extensionId: string; // ObjectId reference to extension registry
+    orgId: string; // Organization ID
+    installedVersion: string;
+    installedBy: string; // User ObjectId as string
+}
+
+/**
+ * Input type for updating installed extensions
+ */
+export interface IUpdateInstalledExtensionInput {
+    status?: string;
+    lifecycle?: {
+        registryStatus?: string;
+        isOrphaned?: boolean;
+        deprecationWarningShown?: boolean;
+        autoUpdateBlocked?: boolean;
+        lastRegistryCheck?: string;
+    };
+    policies?: IExtensionPoliciesInput;
+    settings?: IExtensionSettingsInput;
+    runtime?: {
+        activationState?: string;
+        lastActivated?: Date;
+        lastDeactivated?: Date;
+        activationError?: {
+            message: string;
+            code: string;
+            timestamp: string;
+        };
+        metrics?: {
+            activationTime: number;
+            memoryUsage: number;
+            lastMeasured: string;
+        };
+    };
+    lastUpdatedBy?: string;
+    availableVersion?: string;
+}
+
+/**
+ * Filter input for querying installed extensions
+ */
+export interface IInstalledExtensionFilter {
+    accountId?: string; // Account ID for filtering extensions by account
+    orgId?: string; // Organization ID for filtering extensions by organization  
+    extension?: string; // ObjectId as string reference to extension registry
+    status?: string[];
+    'lifecycle.registryStatus'?: string[];
+    'lifecycle.isOrphaned'?: boolean;
+    'settings.effectiveEnabled'?: boolean;
+    installedBy?: string;
+}
+
+/**
+ * Service interface for managing installed extensions
+ * This service handles the lifecycle of extensions after they've been installed from the registry
+ */
+export interface IInstalledExtensionService extends IBaseService<IInstalledExtensionModel> {
+    /**
+     * Install a new extension from the registry
+     */
+    installExtension(input: ICreateInstalledExtensionInput, tenantId: string): Promise<AsDomainType<IInstalledExtensionModel>>;
+
+    /**
+     * Uninstall an extension - now supports accountId and orgId based filtering
+     */
+    uninstallExtension(
+        orgId: string,
+        extensionSlug: string,
+        uninstalledBy: string,
+        tenantId: string
+    ): Promise<boolean>;
+
+    /**
+     * Update an installed extension's configuration or status - now supports accountId and orgId based filtering
+     */
+    updateInstalledExtension(
+        orgId: string,
+        extensionSlug: string,
+        update: IUpdateInstalledExtensionInput,
+        tenantId: string,
+    ): Promise<AsDomainType<IInstalledExtensionModel>>;
+
+    /**
+     * Get a specific installed extension - now supports accountId and orgId based filtering
+     */
+    getInstalledExtension(
+        orgId: string,
+        extensionSlug: string,
+    ): Promise<AsDomainType<IInstalledExtensionModel> | null>;
+
+    /**
+     * Get all installed extensions with optional filtering - now supports accountId and orgId based filtering
+     */
+    getInstalledExtensions(filter: IInstalledExtensionFilter): Promise<AsDomainType<IInstalledExtensionModel>[]>;
+
+    /**
+     * Get all installed extensions for a specific extension by extensionSlug
+     * Useful for finding all organizations that have installed a specific extension
+     */
+    getInstalledExtensionsBySlug(extensionSlug: string): Promise<AsDomainType<IInstalledExtensionModel>[]>;
+
+    /**
+     * Enable/disable an installed extension - now supports accountId and orgId based filtering
+     */
+    toggleExtension(
+        orgId: string,
+        extensionSlug: string,
+        enabled: boolean,
+        toggledBy: string,
+        tenantId: string,
+    ): Promise<AsDomainType<IInstalledExtensionModel>>;
+
+    /**
+     * Update extension settings/configuration - now supports accountId and orgId based filtering
+     */
+    updateExtensionSettings(
+        orgId: string,
+        extensionSlug: string,
+        userConfig: Record<string, unknown>,
+        updatedBy: string,
+        tenantId: string,
+    ): Promise<AsDomainType<IInstalledExtensionModel>>;
+
+    /**
+     * Check for extension updates and return available updates - now supports accountId and orgId based filtering
+     */
+    checkForUpdates(
+        orgId: string,
+        extensionSlug?: string,
+    ): Promise<
+        Array<{
+            extensionId: string;
+            extensionSlug: string;
+            currentVersion: string;
+            availableVersion: string;
+            isSecurityUpdate: boolean;
+        }>
+    >;
+
+    /**
+     * Update an extension to a newer version - now supports accountId and orgId based filtering
+     */
+    updateExtensionVersion(
+        orgId: string,
+        extensionSlug: string,
+        targetVersion: string,
+        updatedBy: string,
+        tenantId: string
+    ): Promise<AsDomainType<IInstalledExtensionModel>>;
+
+    /**
+     * Sync installed extensions with registry status (for orphaned, deprecated, etc.) - now supports accountId and orgId based filtering
+     */
+    syncWithRegistry(orgId: string, tenantId: string): Promise<void>;
+
+    /**
+     * Get extensions that need attention (deprecated, orphaned, security updates, etc.) - now supports accountId and orgId based filtering
+     */
+    getExtensionsNeedingAttention(orgId: string): Promise<AsDomainType<IInstalledExtensionModel>[]>;
+
+    /**
+     * Clean up deprecated or removed extensions based on policies - now supports accountId and orgId based filtering
+     */
+    cleanupExtensions(
+        orgId: string,
+        tenantId: string,
+        dryRun?: boolean,
+    ): Promise<{
+        removed: string[]; // Array of extension ObjectIds
+        deprecated: string[]; // Array of extension ObjectIds
+        warnings: string[];
+    }>;
+
+    /**
+     * Clean up orphaned extensions that exist in installed_extensions but not in system_extension registry
+     */
+    cleanupOrphanedExtensions(
+        orgId: string,
+        tenantId: string,
+        dryRun?: boolean,
+    ): Promise<{
+        removed: string[]; // Array of extension slugs
+        warnings: string[];
+    }>;
+}

package/lib/templates/services/MarketplacePublisherService.ts.template

@@ -0,0 +1,51 @@
+import { IBaseService, IMarketplacePublisherModel, AsDomainType } from 'common/server';
+
+export interface IMarketplacePublisherService extends IBaseService<IMarketplacePublisherModel> {
+    findById(id: string): Promise<AsDomainType<IMarketplacePublisherModel> | null>;
+    findByPublisherName(publisherName: string): Promise<AsDomainType<IMarketplacePublisherModel> | null>;
+    findPublishers(
+        search?: string,
+        orderBy?: string,
+        orderDirection?: 'ASC' | 'DESC',
+        first?: number,
+        after?: number,
+    ): Promise<{
+        publishers: AsDomainType<IMarketplacePublisherModel>[];
+        totalCount: number;
+    }>;
+    createPublisher(data: {
+        displayName: string;
+        publisherName: string;
+        description?: string;
+        website?: string;
+        domain?: string;
+        tenant?: string;
+    }): Promise<AsDomainType<IMarketplacePublisherModel>>;
+    updatePublisher(
+        publisherId: string,
+        data: {
+            displayName?: string;
+            description?: string;
+            website?: string;
+            avatarUrl?: string;
+            tenant?: string;
+        },
+    ): Promise<AsDomainType<IMarketplacePublisherModel> | null>;
+    updatePublisherStats(
+        publisherId: string,
+        stats: {
+            extensionCount?: number;
+            totalInstalls?: number;
+            averageRating?: number;
+        },
+    ): Promise<AsDomainType<IMarketplacePublisherModel> | null>;
+    verifyPublisher(publisherId: string): Promise<AsDomainType<IMarketplacePublisherModel> | null>;
+    getPublisherStats(publisherId: string): Promise<{
+        totalExtensions: number;
+        totalDownloads: number;
+        totalInstallations: number;
+        averageRating: number;
+        verifiedCount: number;
+        topExtension?: unknown; // TODO: Should be IRegistryExtension when available
+    } | null>;
+}

package/lib/templates/services/PublisherDataLoader.ts.template

@@ -0,0 +1,3 @@
+import { IMarketplacePublisherModel, IDataLoader } from 'common/server';
+
+export type IPublisherDataLoader = IDataLoader<IMarketplacePublisherModel>;

package/lib/templates/services/PublisherEventService.ts.template

@@ -0,0 +1,56 @@
+// from package: marketplace-server
+
+/**
+ * Service interface for managing publisher analytics events
+ */
+export interface IPublisherEventService {
+    recordEvent(event: {
+        publisherId: string;
+        extensionId?: string;
+        eventType: 'download' | 'install' | 'view' | 'rating';
+        value?: number;
+        metadata?: Record<string, unknown>;
+    }): Promise<void>;
+
+    getPublisherStats(publisherId: string): Promise<{
+        totalDownloads: number;
+        totalInstalls: number;
+        totalViews: number;
+        totalRatings: number;
+        averageRating: number;
+        extensionCount: number;
+        lastUpdated: Date;
+    }>;
+
+    getPublisherAnalytics(
+        publisherId: string,
+        startDate: Date,
+        endDate: Date,
+        granularity: string,
+    ): Promise<
+        Array<{
+            date: Date;
+            downloads: number;
+            installs: number;
+            views: number;
+            ratings: number;
+            averageRating: number;
+            uniqueUsers: number;
+        }>
+    >;
+
+    getPublisherTrends(
+        publisherId: string,
+        days: number,
+    ): Promise<{
+        downloadTrend: string;
+        downloadChange: number;
+        installTrend: string;
+        installChange: number;
+        viewTrend: string;
+        viewChange: number;
+        ratingTrend: string;
+        ratingChange: number;
+        trendScore: number;
+    }>;
+}

package/lib/templates/services/RegistryExtensionService.ts.template

@@ -1,19 +1,63 @@
-import { IPublishRequest, IExtensionRelease,IRegistryExtension  } from 'common/server';
-
-export interface IRegistryExtensionService {
-    extensionReleases(extensionID: string): Promise<IExtensionRelease[]>;
-
-    createExtension(publisherId: string, name: string): Promise<IRegistryExtension>;
-
-    updateExtensionName(extensionID: string, name: string);
-
-    updateExtension(extensionID: string, update: { installed?: boolean }): Promise<IRegistryExtension>;
-
-    deleteExtension(extensionID: string): boolean | Promise<boolean>;
-
-    publishExtension(request: IPublishRequest);
-
-    findExtensions(first: number, query: string, local?: boolean, remote?: boolean, prioritizeExtensionIDs?: string[]);
-
-    findExtension(extensionID: string);
+import { IMarketplacePublishExtensionInput, IExtensionRelease, IBaseService, IRegistryExtensionModel, AsDomainType } from 'common/server';
+
+export interface IRegistryExtensionService extends IBaseService<AsDomainType<IRegistryExtensionModel>> {
+    extensionReleases(extensionSlug: string): Promise<IExtensionRelease[]>;
+
+    createExtension(publisherId: string, name: string): Promise<AsDomainType<IRegistryExtensionModel>>;
+
+    updateExtensionName(extensionSlug: string, name: string): Promise<AsDomainType<IRegistryExtensionModel>>;
+
+    updateExtension(extensionSlug: string, update: { installed?: boolean }): Promise<AsDomainType<IRegistryExtensionModel>>;
+
+    deleteExtension(extensionSlug: string): boolean | Promise<boolean>;
+
+    publishExtension(request: IMarketplacePublishExtensionInput): Promise<AsDomainType<IRegistryExtensionModel>>;
+
+    findExtensions(first: number, query: string, local?: boolean, remote?: boolean, prioritizeExtensionIDs?: string[]): Promise<AsDomainType<IRegistryExtensionModel>[]>;
+
+    findExtension(extensionSlug: string): Promise<AsDomainType<IRegistryExtensionModel>>;
+
+    // Enhanced marketplace features
+    formSubmission(input: {
+        extensionSlug: string;
+        formData: string;
+        submissionType: string;
+        metadata?: string;
+    }): Promise<{
+        success: boolean;
+        message?: string;
+        errors?: string[];
+        submissionId?: string;
+        data?: string;
+    }>;
+
+    validateExtension(input: {
+        manifest: string;
+        bundle?: string;
+        sourceMap?: string;
+        extensionSlug?: string;
+        version?: string;
+    }): Promise<{
+        isValid: boolean;
+        errors: Array<{ field: string; message: string; code?: string }>;
+        warnings: Array<{ field: string; message: string; code?: string }>;
+        metadata?: string;
+    }>;
+
+    publishExtensionEnhanced(input: {
+        extensionSlug: string;
+        manifest: string;
+        bundle: string;
+        sourceMap?: string;
+        version: string;
+        releaseNotes?: string;
+        force?: boolean;
+        preRelease?: boolean;
+    }): Promise<{
+        success: boolean;
+        extension?: AsDomainType<IRegistryExtensionModel>;
+        message?: string;
+        errors?: string[];
+        releaseId?: string;
+    }>;
 }

package/lib/tests/extension-integration.test.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=extension-integration.test.d.ts.map

package/lib/tests/extension-integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extension-integration.test.d.ts","sourceRoot":"","sources":["../../src/tests/extension-integration.test.ts"],"names":[],"mappings":""}

package/lib/tests/install-extension-graphql.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=install-extension-graphql.test.d.ts.map

package/lib/tests/install-extension-graphql.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"install-extension-graphql.test.d.ts","sourceRoot":"","sources":["../../src/tests/install-extension-graphql.test.ts"],"names":[],"mappings":""}

package/lib/tests/test-extension-services.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=test-extension-services.d.ts.map

package/lib/tests/test-extension-services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-extension-services.d.ts","sourceRoot":"","sources":["../../src/tests/test-extension-services.ts"],"names":[],"mappings":""}