@arch-cadre/modules 0.0.49 → 0.0.50

package/dist/server/lifecycle.mjs

@@ -1,188 +1,238 @@
 "use server";
-
-import { getModuleInstance, getModules } from "./manage.mjs";
-import { db } from "@arch-cadre/core/server";
+import { exec } from "node:child_process";
 import fs from "node:fs/promises";
 import path from "node:path";
+import { promisify } from "node:util";
 import { systemModulesTable } from "@arch-cadre/core";
+import { db } from "@arch-cadre/core/server";
 import { eq } from "drizzle-orm";
-import { exec } from "node:child_process";
-import { promisify } from "node:util";
-
-//#region src/server/lifecycle.ts
+import { getModuleInstance, getModules } from "./manage.js";
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 async function updateStep(moduleId, step) {
-	console.log(`[Kernel] "${moduleId}" step: ${step}`);
-	await db.update(systemModulesTable).set({ lastStep: step }).where(eq(systemModulesTable.id, moduleId));
+  console.log(`[Kernel] "${moduleId}" step: ${step}`);
+  await db.update(systemModulesTable).set({ lastStep: step }).where(eq(systemModulesTable.id, moduleId));
 }
 async function resolveSchemaPath(moduleId) {
-	const root = process.cwd();
-	if (moduleId === "@arch-cadre/core" || moduleId === "core") {
-		const p = path.join(root, "node_modules", "@kryo", "core", "dist", "server", "database", "schema.cjs");
-		try {
-			await fs.access(p);
-			return p;
-		} catch {
-			const devP = path.resolve(root, "../../packages/kryo-core/src/server/database/schema.ts");
-			try {
-				await fs.access(devP);
-				return devP;
-			} catch {}
-		}
-		return null;
-	}
-	const cleanId = moduleId.replace("@arch-cadre/", "");
-	const possible = [
-		path.join(root, "modules", cleanId, "schema.ts"),
-		path.join(root, "modules", moduleId, "schema.ts"),
-		path.join(root, "node_modules", moduleId, "dist", "schema.cjs"),
-		path.join(root, "node_modules", `@arch-cadre/${cleanId}`, "dist", "schema.cjs"),
-		path.join(root, "node_modules", moduleId, "src", "schema.ts"),
-		path.join(root, "node_modules", `@arch-cadre/${cleanId}`, "src", "schema.ts"),
-		path.resolve(root, "../../packages", cleanId, "src", "schema.ts"),
-		path.resolve(root, "../../packages", `kryo-${cleanId}`, "src", "schema.ts"),
-		path.resolve(root, "../../packages", cleanId, "schema.ts")
-	];
-	for (const p of possible) try {
-		await fs.access(p);
-		console.log(`[Kernel:Lifecycle] Resolved schema for ${moduleId} at: ${p}`);
-		return p;
-	} catch {
-		console.warn(`[Kernel:Lifecycle] Unresolved schema for ${moduleId} at: ${p}`);
-	}
-	console.warn(`[Kernel:Lifecycle] Could not resolve schema path for: ${moduleId}`);
-	return null;
+  const root = process.cwd();
+  if (moduleId === "@arch-cadre/core" || moduleId === "core") {
+    const p = path.join(
+      root,
+      "node_modules",
+      "@kryo",
+      "core",
+      "dist",
+      "server",
+      "database",
+      "schema.cjs"
+    );
+    try {
+      await fs.access(p);
+      return p;
+    } catch {
+      const devP = path.resolve(
+        root,
+        "../../packages/kryo-core/src/server/database/schema.ts"
+      );
+      try {
+        await fs.access(devP);
+        return devP;
+      } catch {
+      }
+    }
+    return null;
+  }
+  const cleanId = moduleId.replace("@arch-cadre/", "");
+  const possible = [
+    // Local module
+    path.join(root, "modules", cleanId, "schema.ts"),
+    path.join(root, "modules", moduleId, "schema.ts"),
+    // node_modules (installed or symlinked)
+    path.join(root, "node_modules", moduleId, "dist", "schema.cjs"),
+    path.join(
+      root,
+      "node_modules",
+      `@arch-cadre/${cleanId}`,
+      "dist",
+      "schema.cjs"
+    ),
+    path.join(root, "node_modules", moduleId, "src", "schema.ts"),
+    path.join(
+      root,
+      "node_modules",
+      `@arch-cadre/${cleanId}`,
+      "src",
+      "schema.ts"
+    ),
+    // Monorepo packages (searching by various naming conventions)
+    path.resolve(root, "../../packages", cleanId, "src", "schema.ts"),
+    path.resolve(root, "../../packages", `kryo-${cleanId}`, "src", "schema.ts"),
+    path.resolve(root, "../../packages", cleanId, "schema.ts")
+  ];
+  for (const p of possible) {
+    try {
+      await fs.access(p);
+      console.log(
+        `[Kernel:Lifecycle] Resolved schema for ${moduleId} at: ${p}`
+      );
+      return p;
+    } catch {
+      console.warn(
+        `[Kernel:Lifecycle] Unresolved schema for ${moduleId} at: ${p}`
+      );
+    }
+  }
+  console.warn(
+    `[Kernel:Lifecycle] Could not resolve schema path for: ${moduleId}`
+  );
+  return null;
 }
-async function pushModuleSchema(moduleId) {
-	const execAsync = promisify(exec);
-	console.log(`[Kernel:Lifecycle] Targeted sync for module: ${moduleId}`);
-	const root = process.cwd();
-	const enabledFromDb = await db.select({ id: systemModulesTable.id }).from(systemModulesTable).where(eq(systemModulesTable.enabled, true));
-	const activeModuleIds = new Set(enabledFromDb.map((m) => m.id));
-	activeModuleIds.add("@arch-cadre/core");
-	activeModuleIds.add(moduleId);
-	const schemaPaths = [];
-	for (const id of Array.from(activeModuleIds)) {
-		const p = await resolveSchemaPath(id);
-		if (p) schemaPaths.push(p);
-	}
-	if (schemaPaths.length === 0) {
-		console.warn(`[Kernel:Lifecycle] No schema paths resolved for ${moduleId}, skipping push.`);
-		return;
-	}
-	const configPath = path.join(root, "drizzle.config.ts");
-	const cmd = `"${path.join(root, "node_modules", ".bin", "drizzle-kit")}" push --force --config=${configPath}`;
-	console.log(`[Kernel:Lifecycle] Executing isolated migration. Modules: ${Array.from(activeModuleIds).join(", ")}`);
-	try {
-		await execAsync(cmd, {
-			env: {
-				...process.env,
-				CI: "true",
-				DRIZZLE_SCHEMA_OVERRIDE: schemaPaths.join(",")
-			},
-			cwd: root
-		});
-		console.log(`[Kernel:Lifecycle] Isolated migration successful for ${moduleId}`);
-	} catch (e) {
-		console.error(`[Kernel:Lifecycle] Isolated migration failed for ${moduleId}:`);
-		console.error(e.stdout || e.message);
-		throw new Error(`Migration failed: ${moduleId}`);
-	}
+export async function pushModuleSchema(moduleId) {
+  const execAsync = promisify(exec);
+  console.log(`[Kernel:Lifecycle] Targeted sync for module: ${moduleId}`);
+  const root = process.cwd();
+  const enabledFromDb = await db.select({ id: systemModulesTable.id }).from(systemModulesTable).where(eq(systemModulesTable.enabled, true));
+  const activeModuleIds = new Set(enabledFromDb.map((m) => m.id));
+  activeModuleIds.add("@arch-cadre/core");
+  activeModuleIds.add(moduleId);
+  const schemaPaths = [];
+  for (const id of Array.from(activeModuleIds)) {
+    const p = await resolveSchemaPath(id);
+    if (p) schemaPaths.push(p);
+  }
+  if (schemaPaths.length === 0) {
+    console.warn(
+      `[Kernel:Lifecycle] No schema paths resolved for ${moduleId}, skipping push.`
+    );
+    return;
+  }
+  const configPath = path.join(root, "drizzle.config.ts");
+  const drizzleKitBin = path.join(root, "node_modules", ".bin", "drizzle-kit");
+  const cmd = `"${drizzleKitBin}" push --force --config=${configPath}`;
+  console.log(
+    `[Kernel:Lifecycle] Executing isolated migration. Modules: ${Array.from(activeModuleIds).join(", ")}`
+  );
+  try {
+    await execAsync(cmd, {
+      env: {
+        ...process.env,
+        CI: "true",
+        // Pass the calculated schemas to our dynamic drizzle.config.ts
+        DRIZZLE_SCHEMA_OVERRIDE: schemaPaths.join(",")
+      },
+      cwd: root
+    });
+    console.log(
+      `[Kernel:Lifecycle] Isolated migration successful for ${moduleId}`
+    );
+  } catch (e) {
+    console.error(
+      `[Kernel:Lifecycle] Isolated migration failed for ${moduleId}:`
+    );
+    console.error(e.stdout || e.message);
+    throw new Error(`Migration failed: ${moduleId}`);
+  }
 }
 async function performToggle(moduleId, isEnabled) {
-	try {
-		const allModules = await getModules();
-		const manifest = allModules.find((m) => m.id === moduleId);
-		await updateStep(moduleId, "Validate module...");
-		await sleep(500);
-		if (!manifest) return;
-		if (isEnabled) {
-			await updateStep(moduleId, "Queued...");
-			await sleep(500);
-			if (manifest.dependencies?.length) {
-				const pendingDeps = manifest.dependencies.filter((depId) => {
-					const dep = allModules.find((m) => m.id === depId);
-					return dep && !dep.enabled && !dep.system;
-				});
-				if (pendingDeps.length > 0) for (const depId of pendingDeps) {
-					await updateStep(moduleId, `Waiting for dependency "${depId}"...`);
-					await performToggle(depId, true);
-					await sleep(500);
-				}
-			}
-			await updateStep(moduleId, "Initializing...");
-			await sleep(500);
-			await db.update(systemModulesTable).set({ enabled: true }).where(eq(systemModulesTable.id, moduleId));
-			const instance = await getModuleInstance(moduleId);
-			await updateStep(moduleId, "Migrate database...");
-			await sleep(500);
-			try {
-				if (instance?.onMigrate) await instance.onMigrate();
-				else await pushModuleSchema(moduleId);
-				await updateStep(moduleId, "Migration successful");
-			} catch (e) {
-				console.error(`[Kernel] Migration failed for ${moduleId}:`, e);
-				await updateStep(moduleId, `Migration failed: ${e.message}`);
-				await sleep(500);
-			}
-			if (instance?.onEnable) {
-				await updateStep(moduleId, "Running setup...");
-				await sleep(500);
-				await instance.onEnable();
-			}
-			await updateStep(moduleId, "Finishing...");
-			await sleep(500);
-			await db.update(systemModulesTable).set({
-				installed: true,
-				lastStep: null
-			}).where(eq(systemModulesTable.id, moduleId));
-		} else {
-			const dependents = allModules.filter((m) => {
-				if (!m.enabled || m.id === moduleId) return false;
-				if (m.dependencies?.includes(moduleId)) return true;
-				if (m.extends?.includes(moduleId)) return m.extends.filter((targetId) => {
-					if (targetId === moduleId) return false;
-					return allModules.find((mod) => mod.id === targetId)?.enabled;
-				}).length === 0;
-				return false;
-			});
-			if (dependents.length > 0) {
-				await updateStep(moduleId, `Deactivating dependents...`);
-				for (const dep of dependents) {
-					await performToggle(dep.id, false);
-					await sleep(500);
-				}
-			}
-			await updateStep(moduleId, "Deactivating...");
-			const instance = await getModuleInstance(moduleId);
-			if (instance?.onDisable) await instance.onDisable();
-			await db.update(systemModulesTable).set({
-				enabled: false,
-				installed: false
-			}).where(eq(systemModulesTable.id, moduleId));
-			await updateStep(moduleId, null);
-		}
-	} catch (e) {
-		console.error(`[Kernel] Fatal error for ${moduleId}:`, e);
-		await updateStep(moduleId, `Error: ${e.message}`);
-	}
+  try {
+    const allModules = await getModules();
+    const manifest = allModules.find((m) => m.id === moduleId);
+    await updateStep(moduleId, "Validate module...");
+    await sleep(500);
+    if (!manifest) return;
+    if (isEnabled) {
+      await updateStep(moduleId, "Queued...");
+      await sleep(500);
+      if (manifest.dependencies?.length) {
+        const pendingDeps = manifest.dependencies.filter((depId) => {
+          const dep = allModules.find((m) => m.id === depId);
+          return dep && !dep.enabled && !dep.system;
+        });
+        if (pendingDeps.length > 0) {
+          for (const depId of pendingDeps) {
+            await updateStep(moduleId, `Waiting for dependency "${depId}"...`);
+            await performToggle(depId, true);
+            await sleep(500);
+          }
+        }
+      }
+      await updateStep(moduleId, "Initializing...");
+      await sleep(500);
+      await db.update(systemModulesTable).set({ enabled: true }).where(eq(systemModulesTable.id, moduleId));
+      const instance = await getModuleInstance(moduleId);
+      await updateStep(moduleId, "Migrate database...");
+      await sleep(500);
+      try {
+        if (instance?.onMigrate) {
+          await instance.onMigrate();
+        } else {
+          await pushModuleSchema(moduleId);
+        }
+        await updateStep(moduleId, "Migration successful");
+      } catch (e) {
+        console.error(`[Kernel] Migration failed for ${moduleId}:`, e);
+        await updateStep(moduleId, `Migration failed: ${e.message}`);
+        await sleep(500);
+      }
+      if (instance?.onEnable) {
+        await updateStep(moduleId, "Running setup...");
+        await sleep(500);
+        await instance.onEnable();
+      }
+      await updateStep(moduleId, "Finishing...");
+      await sleep(500);
+      await db.update(systemModulesTable).set({ installed: true, lastStep: null }).where(eq(systemModulesTable.id, moduleId));
+    } else {
+      const dependents = allModules.filter((m) => {
+        if (!m.enabled || m.id === moduleId) return false;
+        if (m.dependencies?.includes(moduleId)) return true;
+        if (m.extends?.includes(moduleId)) {
+          const otherActiveTargets = m.extends.filter((targetId) => {
+            if (targetId === moduleId) return false;
+            const target = allModules.find((mod) => mod.id === targetId);
+            return target?.enabled;
+          });
+          return otherActiveTargets.length === 0;
+        }
+        return false;
+      });
+      if (dependents.length > 0) {
+        await updateStep(moduleId, `Deactivating dependents...`);
+        for (const dep of dependents) {
+          await performToggle(dep.id, false);
+          await sleep(500);
+        }
+      }
+      await updateStep(moduleId, "Deactivating...");
+      const instance = await getModuleInstance(moduleId);
+      if (instance?.onDisable) await instance.onDisable();
+      await db.update(systemModulesTable).set({ enabled: false, installed: false }).where(eq(systemModulesTable.id, moduleId));
+      await updateStep(moduleId, null);
+    }
+  } catch (e) {
+    console.error(`[Kernel] Fatal error for ${moduleId}:`, e);
+    await updateStep(moduleId, `Error: ${e.message}`);
+  }
 }
-async function toggleModuleState(moduleId, isEnabled) {
-	const manifest = (await getModules()).find((m) => m.id === moduleId);
-	if (!manifest) throw new Error(`Module "${moduleId}" not found`);
-	if (manifest.enabled === isEnabled) return { success: true };
-	performToggle(moduleId, isEnabled);
-	return { success: true };
+export async function toggleModuleState(moduleId, isEnabled) {
+  const allModules = await getModules();
+  const manifest = allModules.find((m) => m.id === moduleId);
+  if (!manifest) throw new Error(`Module "${moduleId}" not found`);
+  if (manifest.enabled === isEnabled) return { success: true };
+  void performToggle(moduleId, isEnabled);
+  return { success: true };
 }
-async function initOperationalModules() {
-	const allModules = await getModules();
-	for (const mod of allModules) if (mod.enabled) try {
-		const instance = await getModuleInstance(mod.id);
-		if (instance?.init) await instance.init();
-	} catch (e) {
-		console.error(`[Kernel] Failed to init module ${mod.id}:`, e);
-	}
+export async function initOperationalModules() {
+  const allModules = await getModules();
+  for (const mod of allModules) {
+    if (mod.enabled) {
+      try {
+        const instance = await getModuleInstance(mod.id);
+        if (instance?.init) {
+          await instance.init();
+        }
+      } catch (e) {
+        console.error(`[Kernel] Failed to init module ${mod.id}:`, e);
+      }
+    }
+  }
 }
-
-//#endregion
-export { initOperationalModules, pushModuleSchema, toggleModuleState };