@openmdm/core 0.2.0 → 0.3.0

package/src/dashboard.ts

@@ -0,0 +1,327 @@
+/**
+ * OpenMDM Dashboard Manager
+ *
+ * Provides analytics and statistics for the MDM dashboard.
+ * Aggregates data from devices, commands, and applications.
+ */
+
+import type {
+  DashboardManager,
+  DashboardStats,
+  DeviceStatusBreakdown,
+  EnrollmentTrendPoint,
+  CommandSuccessRates,
+  AppInstallationSummary,
+  DatabaseAdapter,
+  DeviceStatus,
+} from './types';
+
+/**
+ * Create a DashboardManager instance
+ */
+export function createDashboardManager(db: DatabaseAdapter): DashboardManager {
+  return {
+    async getStats(_tenantId?: string): Promise<DashboardStats> {
+      // Use database method if available
+      if (db.getDashboardStats) {
+        return db.getDashboardStats(_tenantId);
+      }
+
+      // Fallback: compute from individual queries
+      const devices = await db.listDevices({
+        limit: 10000, // Get all for counting
+      });
+
+      const deviceStats = {
+        total: devices.total,
+        enrolled: devices.devices.filter((d) => d.status === 'enrolled').length,
+        active: devices.devices.filter((d) => d.status === 'enrolled').length, // 'active' = 'enrolled' for dashboard
+        blocked: devices.devices.filter((d) => d.status === 'blocked').length,
+        pending: devices.devices.filter((d) => d.status === 'pending').length,
+      };
+
+      const allPolicies = await db.listPolicies();
+      const policyStats = {
+        total: allPolicies.length,
+        deployed: allPolicies.filter((p) => p.isDefault).length,
+      };
+
+      const allApps = await db.listApplications();
+      const appStats = {
+        total: allApps.length,
+        deployed: allApps.length, // All apps in db are considered deployed
+      };
+
+      // Command stats - get recent commands
+      const now = new Date();
+      const yesterday = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+      const allCommands = await db.listCommands({ limit: 10000 });
+
+      const pendingCommands = allCommands.filter((c) => c.status === 'pending');
+      const last24hCommands = allCommands.filter(
+        (c) => new Date(c.createdAt) >= yesterday
+      );
+
+      const commandStats = {
+        pendingCount: pendingCommands.length,
+        last24hTotal: last24hCommands.length,
+        last24hSuccess: last24hCommands.filter((c) => c.status === 'completed').length,
+        last24hFailed: last24hCommands.filter((c) => c.status === 'failed').length,
+      };
+
+      // Group stats
+      const allGroups = await db.listGroups();
+      let groupsWithDevices = 0;
+      for (const group of allGroups) {
+        const groupDevices = await db.listDevicesInGroup(group.id);
+        if (groupDevices.length > 0) groupsWithDevices++;
+      }
+
+      return {
+        devices: deviceStats,
+        policies: policyStats,
+        applications: appStats,
+        commands: commandStats,
+        groups: {
+          total: allGroups.length,
+          withDevices: groupsWithDevices,
+        },
+      };
+    },
+
+    async getDeviceStatusBreakdown(_tenantId?: string): Promise<DeviceStatusBreakdown> {
+      if (db.getDeviceStatusBreakdown) {
+        return db.getDeviceStatusBreakdown(_tenantId);
+      }
+
+      const devices = await db.listDevices({
+        limit: 10000,
+      });
+
+      const byStatus: Record<DeviceStatus, number> = {
+        pending: 0,
+        enrolled: 0,
+        blocked: 0,
+        unenrolled: 0,
+      };
+
+      const byOs: Record<string, number> = {};
+      const byManufacturer: Record<string, number> = {};
+      const byModel: Record<string, number> = {};
+
+      for (const device of devices.devices) {
+        // By status
+        byStatus[device.status]++;
+
+        // By OS version
+        const osKey = device.osVersion || 'Unknown';
+        byOs[osKey] = (byOs[osKey] || 0) + 1;
+
+        // By manufacturer
+        const mfr = device.manufacturer || 'Unknown';
+        byManufacturer[mfr] = (byManufacturer[mfr] || 0) + 1;
+
+        // By model
+        const model = device.model || 'Unknown';
+        byModel[model] = (byModel[model] || 0) + 1;
+      }
+
+      return {
+        byStatus,
+        byOs,
+        byManufacturer,
+        byModel,
+      };
+    },
+
+    async getEnrollmentTrend(days: number, _tenantId?: string): Promise<EnrollmentTrendPoint[]> {
+      if (db.getEnrollmentTrend) {
+        return db.getEnrollmentTrend(days, _tenantId);
+      }
+
+      // Generate trend data from event history
+      const now = new Date();
+      const startDate = new Date(now.getTime() - days * 24 * 60 * 60 * 1000);
+
+      // Get enrollment events
+      const events = await db.listEvents({
+        type: 'device.enrolled',
+        startDate,
+        limit: 10000,
+      });
+
+      const unenrollEvents = await db.listEvents({
+        type: 'device.unenrolled',
+        startDate,
+        limit: 10000,
+      });
+
+      // Group by date
+      const trendByDate = new Map<string, { enrolled: number; unenrolled: number }>();
+
+      // Initialize all dates
+      for (let i = 0; i < days; i++) {
+        const date = new Date(startDate.getTime() + i * 24 * 60 * 60 * 1000);
+        const dateKey = date.toISOString().split('T')[0];
+        trendByDate.set(dateKey, { enrolled: 0, unenrolled: 0 });
+      }
+
+      // Count events
+      for (const event of events) {
+        const dateKey = new Date(event.createdAt).toISOString().split('T')[0];
+        const entry = trendByDate.get(dateKey);
+        if (entry) {
+          entry.enrolled++;
+        }
+      }
+
+      for (const event of unenrollEvents) {
+        const dateKey = new Date(event.createdAt).toISOString().split('T')[0];
+        const entry = trendByDate.get(dateKey);
+        if (entry) {
+          entry.unenrolled++;
+        }
+      }
+
+      // Get initial device count
+      const initialDevices = await db.listDevices({
+        limit: 10000,
+      });
+      let runningTotal = initialDevices.total;
+
+      // Build trend points
+      const result: EnrollmentTrendPoint[] = [];
+      const sortedDates = Array.from(trendByDate.keys()).sort();
+
+      for (const dateKey of sortedDates) {
+        const entry = trendByDate.get(dateKey)!;
+        const netChange = entry.enrolled - entry.unenrolled;
+        runningTotal += netChange;
+
+        result.push({
+          date: new Date(dateKey),
+          enrolled: entry.enrolled,
+          unenrolled: entry.unenrolled,
+          netChange,
+          totalDevices: runningTotal,
+        });
+      }
+
+      return result;
+    },
+
+    async getCommandSuccessRates(_tenantId?: string): Promise<CommandSuccessRates> {
+      if (db.getCommandSuccessRates) {
+        return db.getCommandSuccessRates(_tenantId);
+      }
+
+      const now = new Date();
+      const yesterday = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+
+      const commands = await db.listCommands({ limit: 10000 });
+
+      // Overall stats
+      const completed = commands.filter((c) => c.status === 'completed').length;
+      const failed = commands.filter((c) => c.status === 'failed').length;
+      const total = commands.length;
+
+      // By type
+      const byType: CommandSuccessRates['byType'] = {};
+      for (const cmd of commands) {
+        if (!byType[cmd.type]) {
+          byType[cmd.type] = {
+            total: 0,
+            completed: 0,
+            failed: 0,
+            successRate: 0,
+          };
+        }
+        byType[cmd.type].total++;
+        if (cmd.status === 'completed') byType[cmd.type].completed++;
+        if (cmd.status === 'failed') byType[cmd.type].failed++;
+      }
+
+      // Calculate success rates
+      for (const type of Object.keys(byType)) {
+        const stats = byType[type];
+        const finishedCount = stats.completed + stats.failed;
+        stats.successRate = finishedCount > 0 ? (stats.completed / finishedCount) * 100 : 0;
+      }
+
+      // Last 24h
+      const last24hCommands = commands.filter(
+        (c) => new Date(c.createdAt) >= yesterday
+      );
+
+      return {
+        overall: {
+          total,
+          completed,
+          failed,
+          successRate:
+            completed + failed > 0 ? (completed / (completed + failed)) * 100 : 0,
+        },
+        byType,
+        last24h: {
+          total: last24hCommands.length,
+          completed: last24hCommands.filter((c) => c.status === 'completed').length,
+          failed: last24hCommands.filter((c) => c.status === 'failed').length,
+          pending: last24hCommands.filter((c) => c.status === 'pending').length,
+        },
+      };
+    },
+
+    async getAppInstallationSummary(_tenantId?: string): Promise<AppInstallationSummary> {
+      if (db.getAppInstallationSummary) {
+        return db.getAppInstallationSummary(_tenantId);
+      }
+
+      // Get all apps
+      const apps = await db.listApplications();
+      const appMap = new Map(apps.map((a) => [a.packageName, a]));
+
+      // Get installation statuses if available
+      const byStatus: Record<string, number> = {
+        installed: 0,
+        installing: 0,
+        failed: 0,
+        pending: 0,
+      };
+
+      // Count installed apps per device
+      const installCounts: Record<string, number> = {};
+
+      // Get devices to count installations
+      const devices = await db.listDevices({
+        limit: 10000,
+      });
+
+      for (const device of devices.devices) {
+        if (device.installedApps) {
+          for (const app of device.installedApps) {
+            const key = app.packageName;
+            installCounts[key] = (installCounts[key] || 0) + 1;
+            byStatus['installed']++;
+          }
+        }
+      }
+
+      // Top installed apps
+      const topInstalled = Object.entries(installCounts)
+        .sort(([, a], [, b]) => b - a)
+        .slice(0, 10)
+        .map(([packageName, count]) => ({
+          packageName,
+          name: appMap.get(packageName)?.name || packageName,
+          installedCount: count,
+        }));
+
+      return {
+        total: Object.values(byStatus).reduce((a, b) => a + b, 0),
+        byStatus,
+        recentFailures: [], // Would need installation status tracking
+        topInstalled,
+      };
+    },
+  };
+}

package/src/index.ts

@@ -64,6 +64,15 @@ import type {
   CommandResult,
   InstalledApp,
   WebhookManager,
+  TenantManager,
+  AuthorizationManager,
+  AuditManager,
+  ScheduleManager,
+  MessageQueueManager,
+  DashboardManager,
+  PluginStorageAdapter,
+  GroupTreeNode,
+  GroupHierarchyStats,
 } from './types';
 import {
   DeviceNotFoundError,
@@ -71,6 +80,13 @@ import {
   EnrollmentError,
 } from './types';
 import { createWebhookManager } from './webhooks';
+import { createTenantManager } from './tenant';
+import { createAuthorizationManager } from './authorization';
+import { createAuditManager } from './audit';
+import { createScheduleManager } from './schedule';
+import { createMessageQueueManager } from './queue';
+import { createDashboardManager } from './dashboard';
+import { createPluginStorageAdapter, createMemoryPluginStorageAdapter } from './plugin-storage';
 
 // Re-export all types
 export * from './types';
@@ -78,6 +94,15 @@ export * from './schema';
 export { createWebhookManager, verifyWebhookSignature } from './webhooks';
 export type { WebhookPayload } from './webhooks';
 
+// Re-export enterprise manager factories
+export { createTenantManager } from './tenant';
+export { createAuthorizationManager } from './authorization';
+export { createAuditManager } from './audit';
+export { createScheduleManager } from './schedule';
+export { createMessageQueueManager } from './queue';
+export { createDashboardManager } from './dashboard';
+export { createPluginStorageAdapter, createMemoryPluginStorageAdapter, createPluginKey, parsePluginKey } from './plugin-storage';
+
 /**
  * Create an MDM instance with the given configuration.
  */
@@ -97,6 +122,46 @@ export function createMDM(config: MDMConfig): MDMInstance {
     ? createWebhookManager(webhooksConfig)
     : undefined;
 
+  // ============================================
+  // Enterprise Managers (optional)
+  // ============================================
+
+  // Create tenant manager if multi-tenancy is enabled
+  const tenantManager: TenantManager | undefined = config.multiTenancy?.enabled
+    ? createTenantManager(database)
+    : undefined;
+
+  // Create authorization manager if authorization is enabled
+  const authorizationManager: AuthorizationManager | undefined = config.authorization?.enabled
+    ? createAuthorizationManager(database)
+    : undefined;
+
+  // Create audit manager if audit logging is enabled
+  const auditManager: AuditManager | undefined = config.audit?.enabled
+    ? createAuditManager(database)
+    : undefined;
+
+  // Create schedule manager if scheduling is enabled
+  const scheduleManager: ScheduleManager | undefined = config.scheduling?.enabled
+    ? createScheduleManager(database)
+    : undefined;
+
+  // Create message queue manager if the database supports it
+  const messageQueueManager: MessageQueueManager | undefined = database.enqueueMessage
+    ? createMessageQueueManager(database)
+    : undefined;
+
+  // Create dashboard manager (always available, uses database fallbacks)
+  const dashboardManager: DashboardManager = createDashboardManager(database);
+
+  // Create plugin storage adapter
+  const pluginStorageAdapter: PluginStorageAdapter | undefined =
+    config.pluginStorage?.adapter === 'database'
+      ? createPluginStorageAdapter(database)
+      : config.pluginStorage?.adapter === 'memory'
+        ? createMemoryPluginStorageAdapter()
+        : undefined;
+
   // Event subscription
   const on = <T extends EventType>(
     event: T,
@@ -656,6 +721,155 @@ export function createMDM(config: MDMConfig): MDMInstance {
       const allGroups = await database.listGroups();
       return allGroups.filter((g) => g.parentId === groupId);
     },
+
+    async getTree(rootId?: string): Promise<GroupTreeNode[]> {
+      // Use database implementation if available
+      if (database.getGroupTree) {
+        return database.getGroupTree(rootId);
+      }
+
+      // Fallback: Build tree from flat list
+      const allGroups = await database.listGroups();
+      const groupMap = new Map(allGroups.map((g) => [g.id, g]));
+
+      const buildNode = (group: Group, depth: number, path: string[]): GroupTreeNode => {
+        const children = allGroups
+          .filter((g) => g.parentId === group.id)
+          .map((child) => buildNode(child, depth + 1, [...path, group.id]));
+
+        return {
+          ...group,
+          children,
+          depth,
+          path,
+          effectivePolicyId: group.policyId,
+        };
+      };
+
+      // Find root groups (those with no parent or matching rootId)
+      const roots = allGroups.filter((g) =>
+        rootId ? g.id === rootId : !g.parentId
+      );
+
+      return roots.map((root) => buildNode(root, 0, []));
+    },
+
+    async getAncestors(groupId: string): Promise<Group[]> {
+      // Use database implementation if available
+      if (database.getGroupAncestors) {
+        return database.getGroupAncestors(groupId);
+      }
+
+      // Fallback: Traverse up the tree
+      const ancestors: Group[] = [];
+      const allGroups = await database.listGroups();
+      const groupMap = new Map(allGroups.map((g) => [g.id, g]));
+
+      let current = groupMap.get(groupId);
+      while (current?.parentId) {
+        const parent = groupMap.get(current.parentId);
+        if (parent) {
+          ancestors.push(parent);
+          current = parent;
+        } else {
+          break;
+        }
+      }
+
+      return ancestors;
+    },
+
+    async getDescendants(groupId: string): Promise<Group[]> {
+      // Use database implementation if available
+      if (database.getGroupDescendants) {
+        return database.getGroupDescendants(groupId);
+      }
+
+      // Fallback: Find all descendants recursively
+      const allGroups = await database.listGroups();
+      const descendants: Group[] = [];
+
+      const findDescendants = (parentId: string) => {
+        const children = allGroups.filter((g) => g.parentId === parentId);
+        for (const child of children) {
+          descendants.push(child);
+          findDescendants(child.id);
+        }
+      };
+
+      findDescendants(groupId);
+      return descendants;
+    },
+
+    async move(groupId: string, newParentId: string | null): Promise<Group> {
+      // Validate that we're not creating a cycle
+      if (newParentId) {
+        const ancestors = await this.getAncestors(newParentId);
+        if (ancestors.some((a) => a.id === groupId)) {
+          throw new Error('Cannot move group: would create circular reference');
+        }
+      }
+
+      return database.updateGroup(groupId, { parentId: newParentId });
+    },
+
+    async getEffectivePolicy(groupId: string): Promise<Policy | null> {
+      // Use database implementation if available
+      if (database.getGroupEffectivePolicy) {
+        return database.getGroupEffectivePolicy(groupId);
+      }
+
+      // Fallback: Walk up the tree to find first policy
+      const group = await database.findGroup(groupId);
+      if (!group) return null;
+
+      if (group.policyId) {
+        return database.findPolicy(group.policyId);
+      }
+
+      // Check ancestors
+      const ancestors = await this.getAncestors(groupId);
+      for (const ancestor of ancestors) {
+        if (ancestor.policyId) {
+          return database.findPolicy(ancestor.policyId);
+        }
+      }
+
+      return null;
+    },
+
+    async getHierarchyStats(): Promise<GroupHierarchyStats> {
+      // Use database implementation if available
+      if (database.getGroupHierarchyStats) {
+        return database.getGroupHierarchyStats();
+      }
+
+      // Fallback: Compute from flat list
+      const allGroups = await database.listGroups();
+      let maxDepth = 0;
+      let groupsWithDevices = 0;
+      let groupsWithPolicies = 0;
+
+      for (const group of allGroups) {
+        // Calculate depth
+        const ancestors = await this.getAncestors(group.id);
+        maxDepth = Math.max(maxDepth, ancestors.length);
+
+        // Check for devices
+        const devices = await database.listDevicesInGroup(group.id);
+        if (devices.length > 0) groupsWithDevices++;
+
+        // Check for policies
+        if (group.policyId) groupsWithPolicies++;
+      }
+
+      return {
+        totalGroups: allGroups.length,
+        maxDepth,
+        groupsWithDevices,
+        groupsWithPolicies,
+      };
+    },
   };
 
   // ============================================
@@ -969,6 +1183,14 @@ export function createMDM(config: MDMConfig): MDMInstance {
     verifyDeviceToken,
     getPlugins,
     getPlugin,
+    // Enterprise managers (optional)
+    tenants: tenantManager,
+    authorization: authorizationManager,
+    audit: auditManager,
+    schedules: scheduleManager,
+    messageQueue: messageQueueManager,
+    dashboard: dashboardManager,
+    pluginStorage: pluginStorageAdapter,
   };
 
   // Initialize plugins

package/src/plugin-storage.ts

@@ -0,0 +1,128 @@
+/**
+ * OpenMDM Plugin Storage Manager
+ *
+ * Provides persistent storage for plugin state.
+ * Supports both database-backed and in-memory storage.
+ */
+
+import type { PluginStorageAdapter, DatabaseAdapter } from './types';
+
+/**
+ * Create a PluginStorageAdapter backed by the database
+ */
+export function createPluginStorageAdapter(db: DatabaseAdapter): PluginStorageAdapter {
+  return {
+    async get<T>(pluginName: string, key: string): Promise<T | null> {
+      if (db.getPluginValue) {
+        const value = await db.getPluginValue(pluginName, key);
+        return value as T | null;
+      }
+
+      // Fallback: not supported
+      console.warn('Plugin storage not supported by database adapter');
+      return null;
+    },
+
+    async set<T>(pluginName: string, key: string, value: T): Promise<void> {
+      if (db.setPluginValue) {
+        await db.setPluginValue(pluginName, key, value);
+        return;
+      }
+
+      console.warn('Plugin storage not supported by database adapter');
+    },
+
+    async delete(pluginName: string, key: string): Promise<void> {
+      if (db.deletePluginValue) {
+        await db.deletePluginValue(pluginName, key);
+        return;
+      }
+
+      console.warn('Plugin storage not supported by database adapter');
+    },
+
+    async list(pluginName: string, prefix?: string): Promise<string[]> {
+      if (db.listPluginKeys) {
+        return db.listPluginKeys(pluginName, prefix);
+      }
+
+      console.warn('Plugin storage not supported by database adapter');
+      return [];
+    },
+
+    async clear(pluginName: string): Promise<void> {
+      if (db.clearPluginData) {
+        await db.clearPluginData(pluginName);
+        return;
+      }
+
+      console.warn('Plugin storage not supported by database adapter');
+    },
+  };
+}
+
+/**
+ * Create an in-memory PluginStorageAdapter for testing
+ */
+export function createMemoryPluginStorageAdapter(): PluginStorageAdapter {
+  const store = new Map<string, Map<string, unknown>>();
+
+  function getPluginStore(pluginName: string): Map<string, unknown> {
+    if (!store.has(pluginName)) {
+      store.set(pluginName, new Map());
+    }
+    return store.get(pluginName)!;
+  }
+
+  return {
+    async get<T>(pluginName: string, key: string): Promise<T | null> {
+      const pluginStore = getPluginStore(pluginName);
+      const value = pluginStore.get(key);
+      return value === undefined ? null : (value as T);
+    },
+
+    async set<T>(pluginName: string, key: string, value: T): Promise<void> {
+      const pluginStore = getPluginStore(pluginName);
+      pluginStore.set(key, value);
+    },
+
+    async delete(pluginName: string, key: string): Promise<void> {
+      const pluginStore = getPluginStore(pluginName);
+      pluginStore.delete(key);
+    },
+
+    async list(pluginName: string, prefix?: string): Promise<string[]> {
+      const pluginStore = getPluginStore(pluginName);
+      const keys = Array.from(pluginStore.keys());
+
+      if (prefix) {
+        return keys.filter((k) => k.startsWith(prefix));
+      }
+
+      return keys;
+    },
+
+    async clear(pluginName: string): Promise<void> {
+      store.delete(pluginName);
+    },
+  };
+}
+
+/**
+ * Plugin storage utilities
+ */
+
+/**
+ * Create a namespaced key for plugin storage
+ */
+export function createPluginKey(namespace: string, ...parts: string[]): string {
+  return [namespace, ...parts].join(':');
+}
+
+/**
+ * Parse a namespaced key
+ */
+export function parsePluginKey(key: string): { namespace: string; parts: string[] } {
+  const [namespace, ...parts] = key.split(':');
+  return { namespace, parts };
+}