@adminide-stack/marketplace-module-server 12.0.4-alpha.44 → 12.0.4-alpha.441

package/lib/services/publisher-service.js

@@ -0,0 +1,134 @@
+import {__decorate,__param,__metadata}from'tslib';import {injectable,inject}from'inversify';import'@cdm-logger/core';import {BaseService2}from'@common-stack/store-mongo';import {Emitter,DisposableCollection}from'@adminide-stack/core';import {SERVER_TYPES}from'common/server';import {validatePublisherData}from'../utils/publisherValidation.js';var MarketplacePublisherService_1;
+let MarketplacePublisherService = MarketplacePublisherService_1 = class MarketplacePublisherService extends BaseService2 {
+  onPublisherCreated = new Emitter();
+  onPublisherUpdated = new Emitter();
+  onPublisherVerified = new Emitter();
+  toDispose = new DisposableCollection(this.onPublisherCreated, this.onPublisherUpdated, this.onPublisherVerified);
+  logger;
+  constructor(repository, logger) {
+    super(repository);
+    this.logger = logger.child({
+      className: MarketplacePublisherService_1.name
+    });
+  }
+  dispose() {
+    this.toDispose.dispose();
+  }
+  async findById(id) {
+    this.logger.trace('findById with id [%s]', id);
+    // Use inherited get method from BaseService
+    const result = await this.get(id);
+    this.logger.trace('findById result: %j', result);
+    return result;
+  }
+  async findByPublisherName(publisherName) {
+    this.logger.trace('findByPublisherName with publisherName [%s]', publisherName);
+    const result = await this.repository.findByPublisherName(publisherName);
+    return result ? result : null;
+  }
+  async findPublishers(search, orderBy = 'createdAt', orderDirection = 'DESC', first = 20, after = 0) {
+    this.logger.trace('findPublishers with search [%s], orderBy [%s], orderDirection [%s], first [%d], after [%d]', search, orderBy, orderDirection, first, after);
+    const result = await this.repository.findPublishers(search, orderBy, orderDirection, first, after);
+    return {
+      publishers: result.publishers,
+      totalCount: result.totalCount
+    };
+  }
+  async createPublisher(data) {
+    this.logger.trace('createPublisher with data [%j]', data);
+    // Validate publisher data
+    const validation = validatePublisherData({
+      publisherName: data.publisherName,
+      displayName: data.displayName,
+      email: data.email,
+      website: data.website,
+      description: data.description
+    });
+    if (!validation.valid) {
+      throw new Error(validation.error);
+    }
+    // Check if publisher name already exists
+    const existing = await this.repository.findByPublisherName(data.publisherName);
+    if (existing) {
+      throw new Error(`Publisher with name "${data.publisherName}" already exists`);
+    }
+    const publisherData = {
+      displayName: data.displayName,
+      name: data.publisherName.toLowerCase(),
+      description: data.description,
+      websiteUrl: data.website,
+      email: data.email,
+      verified: false,
+      extensionCount: 0,
+      totalDownloads: 0
+      // Remove fields that don't exist in the model
+      // flags: [],
+      // isDomainVerified: false,
+      // totalInstalls: 0,
+      // averageRating: 0,
+    };
+    const publisher = await this.repository.create(publisherData);
+    this.onPublisherCreated.fire({
+      publisherId: publisher.id,
+      publisherName: publisher.name,
+      displayName: publisher.displayName,
+      createdAt: publisher.createdAt.toISOString()
+    });
+    return publisher;
+  }
+  async updatePublisher(publisherId, data) {
+    this.logger.trace('updatePublisher for publisher [%s] with data [%j]', publisherId, data);
+    const updateData = {
+      ...data,
+      updatedAt: new Date()
+    };
+    const publisher = await this.update(publisherId, updateData);
+    if (publisher) {
+      this.onPublisherUpdated.fire({
+        publisherId: publisher.id,
+        changes: data,
+        updatedAt: publisher.updatedAt.toISOString()
+      });
+    }
+    return publisher ? publisher : null;
+  }
+  async updatePublisherStats(publisherId, stats) {
+    this.logger.trace('updatePublisherStats for publisher [%s] with stats [%j]', publisherId, stats);
+    const result = await this.repository.updatePublisherStats(publisherId, stats);
+    return result ? result : null;
+  }
+  async verifyPublisher(publisherId) {
+    this.logger.trace('verifyPublisher with publisherId [%s]', publisherId);
+    const publisher = await this.update(publisherId, {
+      verified: true
+    });
+    if (publisher) {
+      this.onPublisherVerified.fire({
+        publisherId: publisher.id,
+        verifiedAt: publisher.updatedAt.toISOString()
+      });
+    }
+    return publisher ? publisher : null;
+  }
+  async getPublisherStats(publisherId) {
+    this.logger.trace('getPublisherStats for publisher [%s]', publisherId);
+    const publisher = await this.findById(publisherId);
+    if (!publisher) {
+      return null;
+    }
+    // TODO: Implement proper logic to calculate averageRating, verifiedCount and topExtension
+    // For now, using placeholder values
+    return {
+      totalExtensions: publisher.extensionCount,
+      totalDownloads: publisher.totalDownloads,
+      totalInstallations: publisher.totalDownloads,
+      // Using totalDownloads as approximation
+      averageRating: 0,
+      // TODO: Calculate from actual extension ratings
+      verifiedCount: publisher.verified ? 1 : 0,
+      // Placeholder - should be calculated across all publishers
+      topExtension: null // TODO: Implement logic to find top extension
+    };
+  }
+};
+MarketplacePublisherService = MarketplacePublisherService_1 = __decorate([injectable(), __param(0, inject(SERVER_TYPES.IMarketplacePublisherRepository)), __param(1, inject('Logger')), __metadata("design:paramtypes", [Object, Object])], MarketplacePublisherService);export{MarketplacePublisherService};//# sourceMappingURL=publisher-service.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"publisher-service.js","sources":["../../src/services/publisher-service.ts"],"sourcesContent":[null],"names":[],"mappings":"uVACA,IAAA;+BAoB2B,GAAA,6BAAA,GAAA,MAAA,2BAAA,SAAA,YAAA,CAAA;oBACR,GAAA,IAAM,OAAA,EAAA;AAChB,EAAA,kBAAA,GAAA,IAAA,OAAA,EAAA;qBAEK,GAAS,IAAA,OAAA,EAAA;sCACI,CAAA,IAAA,CAAA,kBAAA,EAAA,IAAA,CAAA,kBAAA,EAAA,IAAA,CAAA,mBAAA,CAAA;AACV,EAAA,MAAA;wBACE,EAAM,MAAA,EAAA;AAChB,IAAA,KAAA,CAAA,UAAA,CAAA;IAEL,IAAA,CAAA,MAAU,GAAA,MAAS,CAAA,KAAA,CAAA;8CACI,CAAA;;AAElB,EAAA;AAEL,EAAA,OAAA,GAAA;IAMA,IAAA,CAAA,SAAc,CAAoB,OAAA,EAAA;AAGwB,EAAA;AAOnD,EAAA,MAAA,QAAW,CAAA,EAAI,EAAA;AAIhB,IAAA,IAAA,CAAA,MAAW,CAAA,KAAE,CAAA,uBAAiB,EAAa,EAAA,CAAA;AAQpC;IAMA,MAAA,MAAA,GACT,MAAM,SAAS,EACf,CAAA;AAKA,IAAA,IAAA,CAAA,MAAA,CAAA,KAAY,CAAA,qBAAa,EAAA,MAAA,CAAA;WACzB,MAAA;;QAuBS,mBAAsB,CAAA,aAAA,EAAA;QAC/B,CAAA,MAAA,CAAA,KAAa,8CAAO,EAAA,aAAA,CAAA;UACpB,MAAA,GAAA,UAAqB,CAAC,UAAA,CAAA,mBAAA,CAAA,aAAA,CAAA;WACtB,MAAA,GAAY,MAAE,GAAO,IAAA;;QAErB,cAAc,CAAC,MAAA,EAAA,OAAA,GAAA,WAAA,EAAA,cAAA,GAAA,MAAA,EAAA,KAAA,GAAA,EAAA,EAAA,KAAA,GAAA,CAAA,EAAA;QACf,CAAA,MAAO,CAAA,KAAE,CAAA,4FAAO,EAAA,MAAA,EAAA,OAAA,EAAA,cAAA,EAAA,KAAA,EAAA,KAAA,CAAA;AACnB,IAAA,YAAW,GAAA,MAAA,IAAa,CAAA,UAAA,CAAA,cAA0B,CAAC,MAAC,EAAA,OAAA,EAAA,cAAA,EAAA,KAAA,EAAA,KAAA,CAAA;AAoDxC,IAAA,OAAA;gBAGL,EAAA,MAAc,CAAA,UAAO;gBACrB,EAAA,MAAc,CAAA;;;QAInB,eAAQ,CAAA,IAAY;AAqBV,IAAA,IAAA,CAAA,MAAA,CAAA,KAAA,CAAA,gCAEF,EAAA,IAAA,CAAA;;UAEH,UAAA,GAAc,qBAAS,CAAA;mBACvB,EAAa,IAAG,CAAA,aAAO;MAC1B,WACM,EAAA,IAAA,CAAA;AASE,MAAA,KAAA,EAAA,IAAA,CAAA,KAAgB;AAchB,MAAA,OAAA,EAAA,IAAA,CAAA,OAAkB;iBAC3B,EAAA,IAAe,CAAA;;QAEf,CAAA,UAAA,CAAA,KAAA,EAAkB;YAClB,IAAA,KAAa,CAAA,UAAS,CAAA,KAAA,CAAA;;;AAGzB,IAAA,cAAQ,GAAA,MAAA,IAAA,CAAA,UAAA,CAAA,mBAAA,CAAA,IAAA,CAAA,aAAA,CAAA;AA0BZ,IAAA,IAAA,QAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/store/index.d.ts

@@ -1,3 +1,3 @@
 export * from './models';
-export * from './repository';
+export * from './repositories';
 //# sourceMappingURL=index.d.ts.map

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

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

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/store/models/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/store/models/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mBAAmB,CAAC"}

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

@@ -0,0 +1,4 @@
+import { IInstalledExtensionModel } from 'common/server';
+import { Connection, Schema } from 'mongoose';
+export declare const InstalledExtensionModelFunc: (db: Connection) => import("mongoose").Model<IInstalledExtensionModel, {}, {}, {}, Schema<IInstalledExtensionModel, import("mongoose").Model<IInstalledExtensionModel, any, any, any, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, IInstalledExtensionModel>>;
+//# sourceMappingURL=installed-extension-model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"installed-extension-model.d.ts","sourceRoot":"","sources":["../../../src/store/models/installed-extension-model.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,wBAAwB,EAQ3B,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAqP9C,eAAO,MAAM,2BAA2B,GAAI,IAAI,UAAU,gQACe,CAAC"}

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