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

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

@@ -0,0 +1,297 @@
+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({
+  tenantId: {
+    type: String,
+    required: true,
+    index: true
+  },
+  extension: {
+    type: Schema.Types.ObjectId,
+    ref: DB_COLL_NAMES.ExtensionRegistries,
+    required: true,
+    index: true
+  },
+  installedVersion: {
+    type: String,
+    required: true,
+    index: true
+  },
+  status: {
+    type: String,
+    enum: ['installed', 'deprecated-installed', 'suspended', 'orphaned', 'force-disabled'],
+    default: 'installed',
+    index: true
+  },
+  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: []
+  }
+});
+// Create virtual for id
+InstalledExtensionSchema.virtual('id').get(function () {
+  return this._id.toHexString();
+});
+// Create compound indexes for efficient queries
+InstalledExtensionSchema.index({
+  tenantId: 1,
+  extension: 1
+}, {
+  unique: true
+});
+InstalledExtensionSchema.index({
+  tenantId: 1,
+  status: 1
+});
+InstalledExtensionSchema.index({
+  tenantId: 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;
+    if (ret.extension) {
+      ret.extension = ret.extension.toString();
+    }
+    if (ret.installedBy) {
+      ret.installedBy = ret.installedBy.toString();
+    }
+    if (ret.lastUpdatedBy) {
+      ret.lastUpdatedBy = ret.lastUpdatedBy.toString();
+    }
+    // Transform audit log ObjectIds to strings
+    if (ret.auditLog && Array.isArray(ret.auditLog)) {
+      ret.auditLog = ret.auditLog.map(entry => ({
+        ...entry,
+        id: entry._id?.toString(),
+        _id: undefined,
+        user: entry.user?.toString()
+      }));
+    }
+    return ret;
+  }
+});
+// Configure toObject transformation
+InstalledExtensionSchema.set('toObject', {
+  virtuals: true,
+  transform: (doc, ret) => {
+    ret.id = ret._id.toString();
+    delete ret._id;
+    delete ret.__v;
+    if (ret.extension) {
+      ret.extension = ret.extension.toString();
+    }
+    if (ret.installedBy) {
+      ret.installedBy = ret.installedBy.toString();
+    }
+    if (ret.lastUpdatedBy) {
+      ret.lastUpdatedBy = ret.lastUpdatedBy.toString();
+    }
+    // Transform audit log ObjectIds to strings
+    if (ret.auditLog && Array.isArray(ret.auditLog)) {
+      ret.auditLog = ret.auditLog.map(entry => ({
+        ...entry,
+        id: entry._id?.toString(),
+        _id: undefined,
+        user: entry.user?.toString()
+      }));
+    }
+    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":"wEAoSA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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

@@ -1,10 +1,5 @@
-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;
-}
+import { Model, Connection } from 'mongoose';
+import { IRegistryExtensionModel } from 'common/server';
 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 +1 @@
-{"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"}
+{"version":3,"file":"registry-extension-model.d.ts","sourceRoot":"","sources":["../../../src/store/models/registry-extension-model.ts"],"names":[],"mappings":"AACA,OAAO,EAAU,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AACrD,OAAO,EAAE,uBAAuB,EAAyC,MAAM,eAAe,CAAC;AAmF/F,MAAM,MAAM,0BAA0B,GAAG,KAAK,CAAC,uBAAuB,CAAC,CAAC;AACxE,eAAO,MAAM,0BAA0B,EAAE,CAAC,EAAE,EAAE,UAAU,KAAK,0BACoC,CAAC"}

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

@@ -1,4 +1,5 @@
-import {find}from'lodash-es';import {Schema}from'mongoose';import {customAlphabet}from'nanoid';const createRandom = customAlphabet('0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', 15);
+import {find}from'lodash-es';import {Schema}from'mongoose';import {DB_COLL_NAMES}from'common/server';import {customAlphabet}from'nanoid';const createRandom = customAlphabet('0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', 15);
+// Define the actual release schema structure that matches MongoDB document
 const RegistryExtensionReleaseSchema = new Schema({
   creatorUserId: {
     type: String
@@ -6,9 +7,7 @@ const RegistryExtensionReleaseSchema = new Schema({
   releaseVersion: {
     type: String
   },
-  extensionID: String,
-  activationEvents: [String],
-  type: String,
+  extensionSlug: String,
   manifest: {
     type: String
   },
@@ -20,35 +19,57 @@ const RegistryExtensionReleaseSchema = new Schema({
   },
   sourceMap: {
     type: String
-  }
+  },
+  // activationEvents: [String],
+  bundleURL: String
 }, {
-  strict: false
+  strict: true
 });
 const RegistryExtensionSchema = new Schema({
-  type: String,
-  version: String,
-  extensionID: String,
-  publisherId: String,
-  activationEvents: [String],
-  uuid: {
+  extensionSlug: String,
+  extensionIDWithoutRegistry: String,
+  isLocal: Boolean,
+  name: {
     type: String,
+    required: true,
     default: () => createRandom()
   },
-  name: {
+  releases: [RegistryExtensionReleaseSchema],
+  remoteURL: String,
+  updatedAt: Date,
+  url: String,
+  uuid: {
     type: String,
+    required: true,
     default: () => createRandom()
   },
-  releases: [{
-    type: RegistryExtensionReleaseSchema
-  }]
+  version: String,
+  viewerCanAdminister: Boolean
 }, {
-  strict: false
+  strict: true,
+  timestamps: true
 });
 RegistryExtensionSchema.virtual('manifest').get(function () {
   const release = find(this.releases, {
     version: this.version
   });
-  return release.manifest || {};
+  if (!release || !release.manifest) {
+    return null;
+  }
+  try {
+    // Parse the JSON string manifest to create a proper ExtensionManifest object
+    const parsedManifest = JSON.parse(release.manifest);
+    return {
+      ...parsedManifest,
+      raw: release.manifest // Keep the original raw JSON for backwards compatibility
+    };
+  } catch (error) {
+    console.warn('Failed to parse extension manifest for', this.extensionSlug, ':', error);
+    // Fallback to raw string format for backwards compatibility
+    return {
+      raw: release.manifest
+    };
+  }
 });
 RegistryExtensionSchema.virtual('id').get(function () {
   return this._id.toHexString();
@@ -59,4 +80,4 @@ RegistryExtensionSchema.set('toJSON', {
 RegistryExtensionSchema.set('toObject', {
   virtuals: true
 });
-const RegistryExtensionModelFunc = db => db.model('extension', RegistryExtensionSchema);export{RegistryExtensionModelFunc};//# sourceMappingURL=registry-extension-model.js.map
+const RegistryExtensionModelFunc = db => db.model(DB_COLL_NAMES.ExtensionRegistries, RegistryExtensionSchema);export{RegistryExtensionModelFunc};//# sourceMappingURL=registry-extension-model.js.map

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

@@ -1 +1 @@
-{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"registry-extension-model.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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

@@ -0,0 +1,3 @@
+export * from './registry-extension-repository';
+export * from './installed-extension-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,iCAAiC,CAAC;AAChD,cAAc,kCAAkC,CAAC"}

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

@@ -0,0 +1,71 @@
+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);
+    findByTenantAndId(tenantId: string, extensionSlug: 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(tenantId: string, extensionSlug: string, update: IUpdateInstalledExtensionInput): Promise<AsDomainType<IInstalledExtensionModel> | null>;
+    /**
+     * Find a specific installed extension
+     */
+    findOne(tenantId: string, extensionSlug: string): Promise<AsDomainType<IInstalledExtensionModel> | null>;
+    /**
+     * Find installed extensions with optional filtering
+     */
+    findExtensions(query: IInstalledExtensionFilter): Promise<AsDomainType<IInstalledExtensionModel>[]>;
+    /**
+     * Delete an installed extension
+     */
+    deleteExtension(tenantId: string, extensionSlug: string): Promise<boolean>;
+    /**
+     * Get installed extensions joined with registry information
+     */
+    findWithRegistryInfo(query: IInstalledExtensionFilter): Promise<any[]>;
+    /**
+     * Check if extension exists for tenant
+     */
+    exists(tenantId: string, extensionSlug: 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<{
+            extensionSlug: string;
+            dependsOn: string[];
+            dependents: string[];
+        }>;
+    }>;
+    /**
+     * Count installed extensions matching query
+     */
+    count(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<{
+        tenantId: string;
+        extensionSlug: 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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"}