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

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

@@ -0,0 +1,269 @@
+import {DB_COLL_NAMES}from'common/server';import {Schema}from'mongoose';// Schema for extension lifecycle management
+const ExtensionLifecycleSchema = new Schema({
+  registryStatus: {
+    type: String,
+    enum: ['active', 'deprecated', 'suspended', 'removed', 'emergency-removed'],
+    required: true,
+    default: 'active'
+  },
+  isOrphaned: {
+    type: Boolean,
+    default: false
+  },
+  deprecationWarningShown: {
+    type: Boolean,
+    default: false
+  },
+  autoUpdateBlocked: {
+    type: Boolean,
+    default: false
+  },
+  lastRegistryCheck: {
+    type: String,
+    default: () => new Date().toISOString()
+  }
+});
+// Schema for extension policies
+const ExtensionPoliciesSchema = new Schema({
+  allowOrphanedExecution: {
+    type: Boolean,
+    default: false
+  },
+  requireSecurityUpdates: {
+    type: Boolean,
+    default: true
+  },
+  autoRemoveDeprecated: {
+    type: Boolean,
+    default: false
+  },
+  deprecationGracePeriod: {
+    type: Number,
+    default: 30 // days
+  }
+});
+// Schema for extension settings
+const ExtensionSettingsSchema = new Schema({
+  userEnabled: {
+    type: Boolean,
+    default: true
+  },
+  systemEnabled: {
+    type: Boolean,
+    default: true
+  },
+  effectiveEnabled: {
+    type: Boolean,
+    default: true
+  },
+  userConfig: {
+    type: Schema.Types.Mixed,
+    default: () => ({})
+  },
+  systemConfig: {
+    type: Schema.Types.Mixed,
+    default: () => ({})
+  }
+});
+// Schema for activation error
+const ActivationErrorSchema = new Schema({
+  message: {
+    type: String,
+    required: true
+  },
+  code: {
+    type: String,
+    required: true
+  },
+  timestamp: {
+    type: String,
+    required: true
+  }
+});
+// Schema for metrics
+const MetricsSchema = new Schema({
+  activationTime: {
+    type: Number,
+    required: true
+  },
+  // milliseconds
+  memoryUsage: {
+    type: Number,
+    required: true
+  },
+  // bytes
+  lastMeasured: {
+    type: String,
+    required: true
+  }
+});
+// Schema for extension runtime information
+const ExtensionRuntimeSchema = new Schema({
+  activationState: {
+    type: String,
+    enum: ['enabled', 'disabled', 'disabled-by-user', 'disabled-by-admin', 'disabled-by-policy'],
+    default: 'enabled'
+  },
+  lastActivated: {
+    type: Date
+  },
+  lastDeactivated: {
+    type: Date
+  },
+  activationError: ActivationErrorSchema,
+  metrics: MetricsSchema
+});
+// Schema for audit log entries
+const AuditLogSchema = new Schema({
+  action: {
+    type: String,
+    enum: ['installed', 'updated', 'enabled', 'disabled', 'configured'],
+    required: true
+  },
+  timestamp: {
+    type: Date,
+    default: Date.now
+  },
+  user: {
+    type: Schema.Types.ObjectId,
+    ref: DB_COLL_NAMES.Accounts,
+    required: true
+  },
+  details: {
+    type: Schema.Types.Mixed
+  }
+});
+// Main installed extension schema
+const InstalledExtensionSchema = new Schema({
+  organization: {
+    type: Schema.Types.ObjectId,
+    ref: DB_COLL_NAMES.Organizations,
+    required: true,
+    index: true
+  },
+  extension: {
+    type: Schema.Types.ObjectId,
+    ref: DB_COLL_NAMES.ExtensionRegistries,
+    required: true
+  },
+  installedVersion: {
+    type: String,
+    required: true,
+    index: true
+  },
+  status: {
+    type: String,
+    enum: ['installed', 'deprecated-installed', 'suspended', 'orphaned', 'force-disabled'],
+    default: 'installed'
+  },
+  lifecycle: {
+    type: ExtensionLifecycleSchema,
+    default: () => ({})
+  },
+  policies: {
+    type: ExtensionPoliciesSchema,
+    default: () => ({})
+  },
+  settings: {
+    type: ExtensionSettingsSchema,
+    default: () => ({})
+  },
+  runtime: {
+    type: ExtensionRuntimeSchema,
+    default: () => ({})
+  },
+  installedAt: {
+    type: Date,
+    default: Date.now,
+    index: true
+  },
+  installedBy: {
+    type: Schema.Types.ObjectId,
+    ref: DB_COLL_NAMES.Accounts,
+    required: true,
+    index: true
+  },
+  lastUpdated: {
+    type: Date
+  },
+  lastUpdatedBy: {
+    type: Schema.Types.ObjectId,
+    ref: DB_COLL_NAMES.Accounts
+  },
+  availableVersion: {
+    type: String
+  },
+  dependencies: {
+    type: [String],
+    default: []
+  },
+  dependents: {
+    type: [String],
+    default: []
+  },
+  auditLog: {
+    type: [AuditLogSchema],
+    default: []
+  },
+  sourceCollection: {
+    type: String
+  },
+  sourceDocumentId: {
+    type: String
+  },
+  metadata: {
+    type: Schema.Types.Mixed
+  }
+});
+// Create virtual for id
+InstalledExtensionSchema.virtual('id').get(function () {
+  return this._id.toHexString();
+});
+// Create compound indexes for efficient queries
+InstalledExtensionSchema.index({
+  organization: 1,
+  extension: 1
+}, {
+  unique: true
+});
+InstalledExtensionSchema.index({
+  organization: 1,
+  status: 1
+});
+InstalledExtensionSchema.index({
+  organization: 1,
+  'settings.effectiveEnabled': 1
+});
+InstalledExtensionSchema.index({
+  'lifecycle.registryStatus': 1
+});
+InstalledExtensionSchema.index({
+  'lifecycle.isOrphaned': 1
+});
+InstalledExtensionSchema.index({
+  installedAt: 1
+});
+InstalledExtensionSchema.index({
+  lastUpdated: 1
+});
+// Configure toJSON transformation
+InstalledExtensionSchema.set('toJSON', {
+  virtuals: true,
+  transform: (doc, ret) => {
+    ret.id = ret._id.toString();
+    delete ret._id;
+    delete ret.__v;
+    return ret;
+  }
+});
+// Configure toObject transformation
+InstalledExtensionSchema.set('toObject', {
+  virtuals: true,
+  transform: (doc, ret) => {
+    ret.id = ret._id.toString();
+    delete ret._id;
+    delete ret.__v;
+    return ret;
+  }
+});
+const InstalledExtensionModelFunc = db => db.model(DB_COLL_NAMES.InstalledExtensions, InstalledExtensionSchema);export{InstalledExtensionModelFunc};//# sourceMappingURL=installed-extension-model.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"installed-extension-model.js","sources":["../../../src/store/models/installed-extension-model.ts"],"sourcesContent":[null],"names":[],"mappings":"wEAgQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/store/models/publisher-event-model.d.ts

@@ -0,0 +1,11 @@
+import * as mongoose from 'mongoose';
+export interface IMarketplacePublisherEventModel extends mongoose.Document {
+    publisherId: string;
+    extensionId?: string;
+    eventType: 'download' | 'install' | 'view' | 'rating';
+    value?: number;
+    metadata?: Record<string, any>;
+    timestamp: Date;
+}
+export declare const PublisherEventModelFunc: (db: mongoose.Connection) => mongoose.Model<IMarketplacePublisherEventModel, {}, {}, {}, any>;
+//# sourceMappingURL=publisher-event-model.d.ts.map

package/lib/store/models/publisher-event-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publisher-event-model.d.ts","sourceRoot":"","sources":["../../../src/store/models/publisher-event-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AAErC,MAAM,WAAW,+BAAgC,SAAQ,QAAQ,CAAC,QAAQ;IACtE,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,UAAU,GAAG,SAAS,GAAG,MAAM,GAAG,QAAQ,CAAC;IACtD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC/B,SAAS,EAAE,IAAI,CAAC;CACnB;AAoBD,eAAO,MAAM,uBAAuB,GAAI,IAAI,QAAQ,CAAC,UAAU,qEACsB,CAAC"}

package/lib/store/models/publisher-model.d.ts

@@ -0,0 +1,5 @@
+import * as mongoose from 'mongoose';
+import { IMarketplacePublisherModel } from 'common/server';
+export declare const PublisherSchema: mongoose.Schema<IMarketplacePublisherModel, mongoose.Model<IMarketplacePublisherModel, any, any, any, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, IMarketplacePublisherModel>;
+export declare const PublisherModelFunc: (db: mongoose.Connection) => mongoose.Model<IMarketplacePublisherModel, {}, {}, {}, any>;
+//# sourceMappingURL=publisher-model.d.ts.map

package/lib/store/models/publisher-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publisher-model.d.ts","sourceRoot":"","sources":["../../../src/store/models/publisher-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AACrC,OAAO,EAAiB,0BAA0B,EAAE,MAAM,eAAe,CAAC;AAG1E,eAAO,MAAM,eAAe,wLAmF3B,CAAC;AAcF,eAAO,MAAM,kBAAkB,GAAI,IAAI,QAAQ,CAAC,UAAU,gEACmC,CAAC"}

package/lib/store/models/publisher-model.js

@@ -0,0 +1,103 @@
+import*as mongoose from'mongoose';import {DB_COLL_NAMES}from'common/server';// Define the publisher model interface
+const PublisherSchema = new mongoose.Schema({
+  displayName: {
+    type: String,
+    required: true,
+    trim: true
+  },
+  name: {
+    type: String,
+    required: true,
+    unique: true,
+    lowercase: true,
+    trim: true
+  },
+  description: String,
+  websiteUrl: String,
+  email: String,
+  // profileUrl: String,
+  // avatarUrl: String,
+  verified: {
+    type: Boolean,
+    default: false
+  },
+  // flags: {
+  //     type: [String],
+  //     default: [],
+  // },
+  // domain: String,
+  // isDomainVerified: {
+  //     type: Boolean,
+  //     default: false,
+  // },
+  // Statistics fields
+  extensionCount: {
+    type: Number,
+    default: 0
+  },
+  totalDownloads: {
+    type: Number,
+    default: 0
+  },
+  // totalInstalls: {
+  //     type: Number,
+  //     default: 0,
+  // },
+  // averageRating: {
+  //     type: Number,
+  //     default: 0,
+  //     min: 0,
+  //     max: 5,
+  // },
+  // Metadata
+  createdAt: {
+    type: Date,
+    default: Date.now
+  },
+  updatedAt: {
+    type: Date,
+    default: Date.now
+  }
+}, {
+  timestamps: true,
+  collection: DB_COLL_NAMES.MarketplacePublisher,
+  toJSON: {
+    virtuals: true,
+    transform(doc, ret) {
+      ret.id = ret._id;
+      delete ret._id;
+      delete ret.__v;
+      return ret;
+    }
+  },
+  toObject: {
+    virtuals: true,
+    transform(doc, ret) {
+      ret.id = ret._id;
+      delete ret._id;
+      delete ret.__v;
+      return ret;
+    }
+  }
+});
+// Indexes
+PublisherSchema.index({
+  publisherName: 1
+}, {
+  unique: true
+});
+PublisherSchema.index({
+  displayName: 1
+});
+PublisherSchema.index({
+  verified: 1
+});
+PublisherSchema.index({
+  createdAt: -1
+});
+// Pre-save middleware to update the updatedAt field
+PublisherSchema.pre('save', function (next) {
+  this.updatedAt = new Date();
+  next();
+});
+const PublisherModelFunc = db => db.model(DB_COLL_NAMES.MarketplacePublisher, PublisherSchema);export{PublisherModelFunc,PublisherSchema};//# sourceMappingURL=publisher-model.js.map

package/lib/store/models/publisher-model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"publisher-model.js","sources":["../../../src/store/models/publisher-model.ts"],"sourcesContent":[null],"names":[],"mappings":"4EAIA;AAiGA,MAAA,8BAAmC,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/store/models/publisher-stats-model.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=publisher-stats-model.d.ts.map

package/lib/store/models/publisher-stats-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publisher-stats-model.d.ts","sourceRoot":"","sources":["../../../src/store/models/publisher-stats-model.ts"],"names":[],"mappings":""}

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

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

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

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

package/lib/store/repositories/installed-extension-repository.d.ts

@@ -0,0 +1,73 @@
+import type { CdmLogger } from '@cdm-logger/core';
+import { IInstalledExtensionModel, ICreateInstalledExtensionInput, IUpdateInstalledExtensionInput, IInstalledExtensionFilter, IInstalledExtensionRepository, AsDomainType } from 'common/server';
+import { BaseMongoRepository } from '@common-stack/store-mongo';
+import * as mongoose from 'mongoose';
+export declare class InstalledExtensionRepository extends BaseMongoRepository<IInstalledExtensionModel> implements IInstalledExtensionRepository {
+    constructor(db: mongoose.Connection, logger: CdmLogger.ILogger, options?: any);
+    findByOrgAndId(orgId: string, extensionSlug: string): Promise<AsDomainType<IInstalledExtensionModel> | null>;
+    findByOrgAndExtensionId(organizationId: string, extensionId: string): Promise<AsDomainType<IInstalledExtensionModel> | null>;
+    countExtensions(filter: IInstalledExtensionFilter): Promise<number>;
+    /**
+     * Create a new installed extension record
+     */
+    createExtension(input: ICreateInstalledExtensionInput): 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
+     */
+    findOne(orgId: string, extensionId: string): Promise<AsDomainType<IInstalledExtensionModel> | null>;
+    /**
+     * Find installed extensions with optional filtering
+     * Uses BaseMongoRepository getAll with population to ensure proper _id to id transformation
+     */
+    findExtensions(query: IInstalledExtensionFilter): Promise<AsDomainType<IInstalledExtensionModel>[]>;
+    /**
+     * Delete an installed extension
+     */
+    deleteExtension(orgId: string, extensionId: string): Promise<boolean>;
+    /**
+     * Get installed extensions joined with registry information
+     */
+    findWithRegistryInfo(query: IInstalledExtensionFilter): Promise<any[]>;
+    /**
+     * Check if extension exists for organization
+     */
+    exists(extensionId: string, orgId?: string): Promise<boolean>;
+    /**
+     * Bulk update multiple extensions
+     */
+    bulkUpdateExtensions(tenantId: string, filter: Partial<IInstalledExtensionFilter>, update: Partial<IUpdateInstalledExtensionInput>): Promise<number>;
+    /**
+     * Get extension dependency graph for a tenant
+     */
+    getDependencyGraph(tenantId: string): Promise<{
+        extensions: AsDomainType<IInstalledExtensionModel>[];
+        dependencies: Array<{
+            extensionId: string;
+            dependsOn: string[];
+            dependents: string[];
+        }>;
+    }>;
+    /**
+     * Count installed extensions matching query
+     */
+    countByQuery(query: IInstalledExtensionFilter): Promise<number>;
+    /**
+     * Find extensions that need registry sync
+     */
+    findStaleExtensions(tenantId: 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>;
+}
+//# sourceMappingURL=installed-extension-repository.d.ts.map

package/lib/store/repositories/installed-extension-repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"installed-extension-repository.d.ts","sourceRoot":"","sources":["../../../src/store/repositories/installed-extension-repository.ts"],"names":[],"mappings":"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"}