@warlock.js/core 4.0.174 → 4.1.2

package/esm/database/seeds/seeder.d.mts

@@ -0,0 +1,44 @@
+import { SeedResult } from "./types.mjs";
+
+//#region ../../@warlock.js/core/src/database/seeds/seeder.d.ts
+type Seeder = {
+  /**
+   * Seed name
+   */
+  name: string;
+  /**
+   * Whether to enable it
+   */
+  enabled?: boolean;
+  /**
+   * Seed description
+   */
+  description?: string;
+  /**
+   * List of dependent seeds to run first
+   */
+  dependsOn?: string[];
+  /**
+   * Whether to run it once
+   */
+  once?: boolean;
+  /**
+   * Seed execution order
+   */
+  order?: number;
+  /**
+   * Batch size
+   */
+  batchSize?: number;
+  /**
+   * Run seed
+   */
+  run(): Promise<SeedResult | void>;
+};
+/**
+ * Create a new seeder
+ */
+declare function seeder(seeder: Seeder): Seeder;
+//#endregion
+export { Seeder, seeder };
+//# sourceMappingURL=seeder.d.mts.map

package/esm/database/seeds/seeder.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seeder.d.mts","names":[],"sources":["../../../../../../../@warlock.js/core/src/database/seeds/seeder.ts"],"mappings":";;;KAEY,MAAA;;AAAZ;;EAIE,IAAA;EA4Bc;;;EAxBd,OAAA;EAQA;;;EAJA,WAAA;EAoBA;;;EAhBA,SAAA;EAgByB;AAM3B;;EAlBE,IAAA;EAkBmC;;;EAdnC,KAAA;EAcmC;AAAA;;EAVnC,SAAA;;;;EAIA,GAAA,IAAO,OAAO,CAAC,UAAA;AAAA;;;;iBAMD,MAAA,CAAO,MAAA,EAAQ,MAAA,GAAM,MAAA"}

package/esm/database/seeds/seeder.mjs

@@ -0,0 +1,11 @@
+//#region ../../@warlock.js/core/src/database/seeds/seeder.ts
+/**
+* Create a new seeder
+*/
+function seeder(seeder) {
+	return seeder;
+}
+
+//#endregion
+export { seeder };
+//# sourceMappingURL=seeder.mjs.map

package/esm/database/seeds/seeder.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"seeder.mjs","names":[],"sources":["../../../../../../../@warlock.js/core/src/database/seeds/seeder.ts"],"sourcesContent":["import { SeedResult } from \"./types\";\n\nexport type Seeder = {\n  /**\n   * Seed name\n   */\n  name: string;\n  /**\n   * Whether to enable it\n   */\n  enabled?: boolean;\n  /**\n   * Seed description\n   */\n  description?: string;\n  /**\n   * List of dependent seeds to run first\n   */\n  dependsOn?: string[];\n  /**\n   * Whether to run it once\n   */\n  once?: boolean;\n  /**\n   * Seed execution order\n   */\n  order?: number;\n  /**\n   * Batch size\n   */\n  batchSize?: number;\n  /**\n   * Run seed\n   */\n  run(): Promise<SeedResult | void>;\n};\n\n/**\n * Create a new seeder\n */\nexport function seeder(seeder: Seeder) {\n  return seeder;\n}\n"],"mappings":";;;;AAwCA,SAAgB,OAAO,QAAgB;CACrC,OAAO;AACT"}

package/esm/database/seeds/seeders.manager.mjs

@@ -0,0 +1,129 @@
+import { seedsTableName } from "./utils.mjs";
+import { SeedsTableMigration } from "./seeds-table-migration.mjs";
+import { DatabaseWriterValidationError, dataSourceRegistry, migrationRunner, transaction } from "@warlock.js/cascade";
+import { colors } from "@mongez/copper";
+
+//#region ../../@warlock.js/core/src/database/seeds/seeders.manager.ts
+var SeedersManager = class {
+	constructor(options) {
+		this.options = options;
+		this.seeders = [];
+		this.datasource = options?.datasource ?? dataSourceRegistry.get();
+	}
+	/**
+	* Register new seeder
+	*/
+	register(...seeders) {
+		this.seeders.push(...seeders);
+		return this;
+	}
+	/**
+	* Initialize before running
+	*/
+	async init() {
+		if (!await this.driver.blueprint.tableExists("_seeds")) await migrationRunner.run(SeedsTableMigration);
+	}
+	/**
+	* Run seeders
+	*/
+	async run(withTransaction = true) {
+		await this.init();
+		this.prepareSeeders();
+		console.log(`🌱 Running ${this.seeders.length} seeder(s)...\n`);
+		let successCount = 0;
+		let skippedCount = 0;
+		let failedCount = 0;
+		for (const seeder of this.seeders) {
+			if (seeder.once && await this.seederIsExecutedBefore(seeder)) {
+				console.log(`⏭️  Skipping ${colors.yellow(seeder.name)} (already executed)`);
+				skippedCount++;
+				continue;
+			}
+			try {
+				console.log(`🔄 Running ${colors.green(seeder.name)}...`);
+				const startTime = Date.now();
+				const result = withTransaction ? await transaction(async () => seeder.run()) : await seeder.run();
+				const duration = Date.now() - startTime;
+				if (result) await this.storeSeedsResults(seeder, result);
+				console.log(`✅ ${colors.green(seeder.name)} completed (${duration}ms, ${result?.recordsCreated ?? 0} records)\n`);
+				successCount++;
+			} catch (error) {
+				const err = error;
+				console.error(`❌ ${colors.red(seeder.name)} failed:`, err.message);
+				console.log(err);
+				failedCount++;
+				if (error instanceof DatabaseWriterValidationError) console.log(error.errors);
+				throw error;
+			}
+		}
+		console.log("\n" + "=".repeat(50));
+		console.log(`✅ Success: ${successCount}`);
+		if (skippedCount > 0) console.log(`⏭️  Skipped: ${skippedCount}`);
+		if (failedCount > 0) console.log(`❌ Failed: ${failedCount}`);
+		console.log("=".repeat(50));
+	}
+	/**
+	* Sort seeds
+	*/
+	sort() {
+		this.seeders = this.seeders.sort((a, b) => {
+			return (a.order ?? Number.MAX_SAFE_INTEGER) - (b.order ?? Number.MAX_SAFE_INTEGER);
+		});
+		return this;
+	}
+	/**
+	* Prepare seeders to order by the seeder order
+	* Also keep an eye on the dependsOn for each seeder to make sure
+	* they are ordered correctly
+	*/
+	prepareSeeders() {
+		this.seeders = this.seeders.filter((seeder) => seeder.enabled !== false);
+		this.sort();
+	}
+	/**
+	* Store seed results in db
+	*/
+	async storeSeedsResults(seeder, result) {
+		const oldResult = await this.getMetadata(seeder);
+		console.log(`📊 Total records created: ${result.recordsCreated}`);
+		if (oldResult) {
+			await this.driver.queryBuilder(seedsTableName).where("name", seeder.name).update({
+				runCount: oldResult.runCount + 1,
+				lastRunAt: /* @__PURE__ */ new Date(),
+				totalRecordsCreated: oldResult.totalRecordsCreated + result.recordsCreated,
+				lastRunRecordsCreated: result.recordsCreated
+			});
+			console.log(`📊 Total records created so far: ${oldResult.totalRecordsCreated + result.recordsCreated}`);
+		} else await this.driver.insert(seedsTableName, {
+			name: seeder.name,
+			createdAt: /* @__PURE__ */ new Date(),
+			firstRunAt: /* @__PURE__ */ new Date(),
+			lastRunAt: /* @__PURE__ */ new Date(),
+			runCount: 1,
+			totalRecordsCreated: result.recordsCreated,
+			lastRunRecordsCreated: result.recordsCreated
+		});
+	}
+	/**
+	* Get seed info from database
+	*/
+	getMetadata(seeder) {
+		return this.datasource.driver.queryBuilder(seedsTableName).where("name", seeder.name).first();
+	}
+	/**
+	* Get driver instance
+	*/
+	get driver() {
+		return this.datasource.driver;
+	}
+	/**
+	* Check if seeder has been executed before
+	*/
+	async seederIsExecutedBefore(seeder) {
+		return !!await this.getMetadata(seeder);
+	}
+};
+
+//#endregion
+export { SeedersManager };
+//# sourceMappingURL=seeders.manager.mjs.map

package/esm/database/seeds/seeders.manager.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"seeders.manager.mjs","names":[],"sources":["../../../../../../../@warlock.js/core/src/database/seeds/seeders.manager.ts"],"sourcesContent":["import { colors } from \"@mongez/copper\";\nimport {\n  type DataSource,\n  type DriverContract,\n  DatabaseWriterValidationError,\n  dataSourceRegistry,\n  migrationRunner,\n  transaction,\n} from \"@warlock.js/cascade\";\nimport { Seeder } from \"./seeder\";\nimport { SeedsTableMigration } from \"./seeds-table-migration\";\nimport { SeederMetadata, SeedResult } from \"./types\";\nimport { seedsTableName } from \"./utils\";\n\nexport type SeedersManagerOptions = {\n  datasource?: DataSource;\n};\n\nexport class SeedersManager {\n  public seeders: Seeder[] = [];\n\n  protected datasource?: DataSource;\n\n  public constructor(protected options?: SeedersManagerOptions) {\n    this.datasource = options?.datasource ?? dataSourceRegistry.get();\n  }\n\n  /**\n   * Register new seeder\n   */\n  public register(...seeders: Seeder[]) {\n    this.seeders.push(...seeders);\n    return this;\n  }\n\n  /**\n   * Initialize before running\n   */\n  protected async init() {\n    if (!(await this.driver.blueprint.tableExists(seedsTableName))) {\n      await migrationRunner.run(SeedsTableMigration);\n    }\n  }\n\n  /**\n   * Run seeders\n   */\n  public async run(withTransaction = true) {\n    await this.init();\n\n    this.prepareSeeders();\n\n    console.log(`🌱 Running ${this.seeders.length} seeder(s)...\\n`);\n\n    let successCount = 0;\n    let skippedCount = 0;\n    let failedCount = 0;\n\n    for (const seeder of this.seeders) {\n      // Check if already executed\n      if (seeder.once && (await this.seederIsExecutedBefore(seeder))) {\n        console.log(`⏭️  Skipping ${colors.yellow(seeder.name)} (already executed)`);\n        skippedCount++;\n        continue;\n      }\n\n      try {\n        console.log(`🔄 Running ${colors.green(seeder.name)}...`);\n        const startTime = Date.now();\n\n        const result = withTransaction\n          ? await transaction(async () => seeder.run())\n          : await seeder.run();\n\n        const duration = Date.now() - startTime;\n        if (result) {\n          await this.storeSeedsResults(seeder, result);\n        }\n\n        console.log(\n          `✅ ${colors.green(seeder.name)} completed (${duration}ms, ${result?.recordsCreated ?? 0} records)\\n`,\n        );\n        successCount++;\n      } catch (error: any) {\n        const err = error as Error;\n        console.error(`❌ ${colors.red(seeder.name)} failed:`, err.message);\n        console.log(err);\n        failedCount++;\n\n        if (error instanceof DatabaseWriterValidationError) {\n          console.log(error.errors);\n        }\n\n        // Re-throw to stop execution (or continue to next seed based on your preference)\n        throw error;\n      }\n    }\n\n    // Summary\n    console.log(\"\\n\" + \"=\".repeat(50));\n    console.log(`✅ Success: ${successCount}`);\n\n    if (skippedCount > 0) console.log(`⏭️  Skipped: ${skippedCount}`);\n\n    if (failedCount > 0) console.log(`❌ Failed: ${failedCount}`);\n\n    console.log(\"=\".repeat(50));\n  }\n\n  /**\n   * Sort seeds\n   */\n  public sort() {\n    this.seeders = this.seeders.sort((a, b) => {\n      const orderA = a.order ?? Number.MAX_SAFE_INTEGER;\n      const orderB = b.order ?? Number.MAX_SAFE_INTEGER;\n      return orderA - orderB;\n    });\n\n    return this;\n  }\n\n  /**\n   * Prepare seeders to order by the seeder order\n   * Also keep an eye on the dependsOn for each seeder to make sure\n   * they are ordered correctly\n   */\n  public prepareSeeders() {\n    this.seeders = this.seeders.filter((seeder) => seeder.enabled !== false);\n\n    this.sort();\n\n    // TODO: Handle dependsOn resolution\n    // This is more complex - needs topological sort\n  }\n\n  /**\n   * Store seed results in db\n   */\n  public async storeSeedsResults(seeder: Seeder, result: SeedResult) {\n    const oldResult = await this.getMetadata(seeder);\n\n    // log with an emoji icon at beginning of text no of total craeted records\n    console.log(`📊 Total records created: ${result.recordsCreated}`);\n\n    if (oldResult) {\n      // Update existing record - use query builder with WHERE clause\n      await this.driver\n        .queryBuilder(seedsTableName)\n        .where(\"name\", seeder.name)\n        .update({\n          runCount: oldResult.runCount + 1,\n          lastRunAt: new Date(),\n          totalRecordsCreated: oldResult.totalRecordsCreated + result.recordsCreated,\n          lastRunRecordsCreated: result.recordsCreated,\n        });\n\n      // now display total created records so far\n      console.log(\n        `📊 Total records created so far: ${oldResult.totalRecordsCreated + result.recordsCreated}`,\n      );\n    } else {\n      // Insert new record\n      await this.driver.insert(seedsTableName, {\n        name: seeder.name,\n        createdAt: new Date(),\n        firstRunAt: new Date(),\n        lastRunAt: new Date(),\n        runCount: 1,\n        totalRecordsCreated: result.recordsCreated,\n        lastRunRecordsCreated: result.recordsCreated,\n      });\n    }\n  }\n\n  /**\n   * Get seed info from database\n   */\n  protected getMetadata(seeder: Seeder): Promise<SeederMetadata> {\n    const driver = this.datasource.driver;\n\n    return driver.queryBuilder(seedsTableName).where(\"name\", seeder.name).first();\n  }\n\n  /**\n   * Get driver instance\n   */\n  protected get driver(): DriverContract {\n    return this.datasource.driver;\n  }\n\n  /**\n   * Check if seeder has been executed before\n   */\n  protected async seederIsExecutedBefore(seeder: Seeder) {\n    return !!(await this.getMetadata(seeder));\n  }\n}\n"],"mappings":"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"}

package/esm/database/seeds/seeds-table-migration.mjs

@@ -0,0 +1,31 @@
+import { seedsTableName } from "./utils.mjs";
+import { Migration } from "@warlock.js/cascade";
+
+//#region ../../@warlock.js/core/src/database/seeds/seeds-table-migration.ts
+var SeedsTableMigration = class extends Migration {
+	constructor(..._args) {
+		super(..._args);
+		this.table = seedsTableName;
+	}
+	static {
+		this.migrationName = "seeds-table-migration";
+	}
+	up() {
+		this.createTableIfNotExists();
+		this.id();
+		this.text("name").unique();
+		this.int("runCount").default(0);
+		this.dateTime("createdAt").useCurrent();
+		this.dateTime("firstRunAt").useCurrent();
+		this.dateTime("lastRunAt").useCurrent();
+		this.int("totalRecordsCreated").default(0);
+		this.int("lastRunRecordsCreated").default(0);
+	}
+	down() {
+		this.dropTableIfExists(seedsTableName);
+	}
+};
+
+//#endregion
+export { SeedsTableMigration };
+//# sourceMappingURL=seeds-table-migration.mjs.map

package/esm/database/seeds/seeds-table-migration.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"seeds-table-migration.mjs","names":[],"sources":["../../../../../../../@warlock.js/core/src/database/seeds/seeds-table-migration.ts"],"sourcesContent":["import { Migration } from \"@warlock.js/cascade\";\nimport { seedsTableName } from \"./utils\";\n\nexport class SeedsTableMigration extends Migration {\n  public static migrationName = \"seeds-table-migration\";\n  public table = seedsTableName;\n\n  public up() {\n    this.createTableIfNotExists();\n\n    this.id();\n    this.text(\"name\").unique();\n    this.int(\"runCount\").default(0);\n    this.dateTime(\"createdAt\").useCurrent();\n    this.dateTime(\"firstRunAt\").useCurrent();\n    this.dateTime(\"lastRunAt\").useCurrent();\n    this.int(\"totalRecordsCreated\").default(0);\n    this.int(\"lastRunRecordsCreated\").default(0);\n  }\n\n  public down() {\n    this.dropTableIfExists(seedsTableName);\n  }\n}\n"],"mappings":";;;;AAGA,IAAa,sBAAb,cAAyC,UAAU;;;eAElC;;;uBADe;;CAG9B,AAAO,KAAK;EACV,KAAK,uBAAuB;EAE5B,KAAK,GAAG;EACR,KAAK,KAAK,MAAM,EAAE,OAAO;EACzB,KAAK,IAAI,UAAU,EAAE,QAAQ,CAAC;EAC9B,KAAK,SAAS,WAAW,EAAE,WAAW;EACtC,KAAK,SAAS,YAAY,EAAE,WAAW;EACvC,KAAK,SAAS,WAAW,EAAE,WAAW;EACtC,KAAK,IAAI,qBAAqB,EAAE,QAAQ,CAAC;EACzC,KAAK,IAAI,uBAAuB,EAAE,QAAQ,CAAC;CAC7C;CAEA,AAAO,OAAO;EACZ,KAAK,kBAAkB,cAAc;CACvC;AACF"}

package/esm/database/seeds/types.d.mts

@@ -0,0 +1,16 @@
+//#region ../../@warlock.js/core/src/database/seeds/types.d.ts
+type SeedResult = {
+  recordsCreated: number;
+};
+type SeederMetadata = {
+  name: string;
+  createdAt: number;
+  firstRunAt: number;
+  lastRunAt: number;
+  runCount: number;
+  totalRecordsCreated: number;
+  lastRunRecordsCreated: number;
+};
+//#endregion
+export { SeedResult, SeederMetadata };
+//# sourceMappingURL=types.d.mts.map

package/esm/database/seeds/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../../../../@warlock.js/core/src/database/seeds/types.ts"],"mappings":";KAAY,UAAA;EACV,cAAc;AAAA;AAAA,KAGJ,cAAA;EACV,IAAA;EACA,SAAA;EACA,UAAA;EACA,SAAA;EACA,QAAA;EACA,mBAAA;EACA,qBAAA;AAAA"}

package/esm/database/seeds/utils.mjs

@@ -0,0 +1,6 @@
+//#region ../../@warlock.js/core/src/database/seeds/utils.ts
+const seedsTableName = "_seeds";
+
+//#endregion
+export { seedsTableName };
+//# sourceMappingURL=utils.mjs.map

package/esm/database/seeds/utils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.mjs","names":[],"sources":["../../../../../../../@warlock.js/core/src/database/seeds/utils.ts"],"sourcesContent":["export const seedsTableName = \"_seeds\";\n"],"mappings":";AAAA,MAAa,iBAAiB"}

package/esm/database/utils.d.mts

@@ -0,0 +1,20 @@
+import { SchemaContext } from "@warlock.js/seal";
+import { Model } from "@warlock.js/cascade";
+
+//#region ../../@warlock.js/core/src/database/utils.d.ts
+/**
+ * Hash password on saving if password changes
+ */
+declare const useHashedPassword: () => any;
+type ComputedCallbackModel = (data: any, model: Model, context: SchemaContext) => any | Promise<any>;
+/**
+ * Generate computed value based on other fields
+ */
+declare function useComputedModel(callback: ComputedCallbackModel): ComputedCallback;
+/**
+ * Generate slug based on a field on saving
+ */
+declare function useComputedSlug(field?: string, scope?: "global" | "sibling"): ComputedCallback;
+//#endregion
+export { useComputedModel, useComputedSlug, useHashedPassword };
+//# sourceMappingURL=utils.d.mts.map

package/esm/database/utils.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/database/utils.ts"],"mappings":";;;;;;AASA;cAAa,iBAAA;AAAA,KASR,qBAAA,IACH,IAAA,OACA,KAAA,EAAO,KAAA,EACP,OAAA,EAAS,aAAA,WACA,OAAA;;AANP;AAAC;iBAWW,gBAAA,CAAiB,QAAA,EAAU,qBAAA,GAAqB,gBAAA;;;;iBAWhD,eAAA,CAAgB,KAAA,WAAiB,KAAA,0BAAuC,gBAAA"}

package/esm/database/utils.mjs

@@ -0,0 +1,37 @@
+import { useModelTransformer } from "@warlock.js/cascade";
+import { slugify } from "@mongez/slug";
+import { get } from "@mongez/reinforcements";
+import { authService } from "@warlock.js/auth";
+
+//#region ../../@warlock.js/core/src/database/utils.ts
+/**
+* Hash password on saving if password changes
+*/
+const useHashedPassword = () => useModelTransformer(({ value, isChanged, isNew }) => {
+	if (!value) return value;
+	if (!isNew && !isChanged) return value;
+	return authService.hashPassword(String(value));
+});
+/**
+* Generate computed value based on other fields
+*/
+function useComputedModel(callback) {
+	const computedCallback = (data, context) => {
+		return callback(data, context.rootContext.model, context);
+	};
+	return computedCallback;
+}
+/**
+* Generate slug based on a field on saving
+*/
+function useComputedSlug(field = "title", scope = "sibling") {
+	return useComputedModel((data, model, context) => {
+		const value = scope === "sibling" ? data[field] : get(context.allValues, field);
+		if (!value) return model.get(field);
+		return slugify(value);
+	});
+}
+
+//#endregion
+export { useComputedModel, useComputedSlug, useHashedPassword };
+//# sourceMappingURL=utils.mjs.map

package/esm/database/utils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/database/utils.ts"],"sourcesContent":["import { get } from \"@mongez/reinforcements\";\nimport { slugify } from \"@mongez/slug\";\nimport { authService } from \"@warlock.js/auth\";\nimport { Model, useModelTransformer } from \"@warlock.js/cascade\";\nimport { ComputedCallback, SchemaContext } from \"@warlock.js/seal\";\n\n/**\n * Hash password on saving if password changes\n */\nexport const useHashedPassword = () =>\n  useModelTransformer(({ value, isChanged, isNew }) => {\n    if (!value) return value;\n\n    if (!isNew && !isChanged) return value;\n\n    return authService.hashPassword(String(value));\n  });\n\ntype ComputedCallbackModel = (\n  data: any,\n  model: Model,\n  context: SchemaContext,\n) => any | Promise<any>;\n\n/**\n * Generate computed value based on other fields\n */\nexport function useComputedModel(callback: ComputedCallbackModel) {\n  const computedCallback: ComputedCallback = (data, context) => {\n    return callback(data, context.rootContext!.model, context);\n  };\n\n  return computedCallback;\n}\n\n/**\n * Generate slug based on a field on saving\n */\nexport function useComputedSlug(field = \"title\", scope: \"global\" | \"sibling\" = \"sibling\") {\n  return useComputedModel((data, model, context) => {\n    const value = scope === \"sibling\" ? data[field] : get(context.allValues, field);\n\n    if (!value) return model.get(field);\n\n    return slugify(value);\n  });\n}\n"],"mappings":";;;;;;;;;AASA,MAAa,0BACX,qBAAqB,EAAE,OAAO,WAAW,YAAY;CACnD,IAAI,CAAC,OAAO,OAAO;CAEnB,IAAI,CAAC,SAAS,CAAC,WAAW,OAAO;CAEjC,OAAO,YAAY,aAAa,OAAO,KAAK,CAAC;AAC/C,CAAC;;;;AAWH,SAAgB,iBAAiB,UAAiC;CAChE,MAAM,oBAAsC,MAAM,YAAY;EAC5D,OAAO,SAAS,MAAM,QAAQ,YAAa,OAAO,OAAO;CAC3D;CAEA,OAAO;AACT;;;;AAKA,SAAgB,gBAAgB,QAAQ,SAAS,QAA8B,WAAW;CACxF,OAAO,kBAAkB,MAAM,OAAO,YAAY;EAChD,MAAM,QAAQ,UAAU,YAAY,KAAK,SAAS,IAAI,QAAQ,WAAW,KAAK;EAE9E,IAAI,CAAC,OAAO,OAAO,MAAM,IAAI,KAAK;EAElC,OAAO,QAAQ,KAAK;CACtB,CAAC;AACH"}

package/esm/dev-server/create-worker.mjs

@@ -0,0 +1,41 @@
+import { env } from "@mongez/dotenv";
+import { fileURLToPath } from "url";
+import { Worker } from "worker_threads";
+
+//#region ../../@warlock.js/core/src/dev-server/create-worker.ts
+/**
+* Create a worker that works in both dev (TypeScript) and production (JavaScript) environments.
+*
+* In development mode (DEV_SERVER_CORE env set), workers are loaded with tsx
+* to support TypeScript execution. In production, compiled .js files are used.
+*
+* @param workerPath - Relative path to worker file WITHOUT extension (e.g., "./workers/ts-health.worker")
+* @param baseUrl - The import.meta.url of the calling module (used to resolve relative paths)
+* @param options - Additional worker options
+* @returns A new Worker instance
+*
+* @example
+* ```typescript
+* // In FilesHealthcareManager
+* const worker = createWorker(
+*   "./workers/ts-health.worker",
+*   import.meta.url,
+*   { workerData: { cwd: process.cwd() } }
+* );
+* ```
+*/
+function createWorker(workerPath, baseUrl, options) {
+	const isDevServerCore = env("DEV_SERVER_CORE");
+	const workerFilePath = fileURLToPath(new URL(`${workerPath}${isDevServerCore ? ".ts" : ".js"}`, baseUrl));
+	const workerOptions = { ...options };
+	if (isDevServerCore) workerOptions.execArgv = [
+		...options?.execArgv || [],
+		"--import",
+		"tsx/esm"
+	];
+	return new Worker(workerFilePath, workerOptions);
+}
+
+//#endregion
+export { createWorker };
+//# sourceMappingURL=create-worker.mjs.map

package/esm/dev-server/create-worker.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-worker.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/dev-server/create-worker.ts"],"sourcesContent":["import { env } from \"@mongez/dotenv\";\nimport { fileURLToPath } from \"url\";\nimport { Worker, type WorkerOptions } from \"worker_threads\";\n\n/**\n * Options for creating a health check worker\n */\nexport type CreateWorkerOptions = WorkerOptions & {\n  /**\n   * Worker data to pass to the worker thread\n   */\n  workerData?: Record<string, unknown>;\n};\n\n/**\n * Create a worker that works in both dev (TypeScript) and production (JavaScript) environments.\n *\n * In development mode (DEV_SERVER_CORE env set), workers are loaded with tsx\n * to support TypeScript execution. In production, compiled .js files are used.\n *\n * @param workerPath - Relative path to worker file WITHOUT extension (e.g., \"./workers/ts-health.worker\")\n * @param baseUrl - The import.meta.url of the calling module (used to resolve relative paths)\n * @param options - Additional worker options\n * @returns A new Worker instance\n *\n * @example\n * ```typescript\n * // In FilesHealthcareManager\n * const worker = createWorker(\n *   \"./workers/ts-health.worker\",\n *   import.meta.url,\n *   { workerData: { cwd: process.cwd() } }\n * );\n * ```\n */\nexport function createWorker(\n  workerPath: string,\n  baseUrl: string,\n  options?: CreateWorkerOptions,\n): Worker {\n  const isDevServerCore = env(\"DEV_SERVER_CORE\");\n\n  // In dev: .ts file with tsx loader\n  // In prod: .js file (compiled)\n  const extension = isDevServerCore ? \".ts\" : \".js\";\n  const workerUrl = new URL(`${workerPath}${extension}`, baseUrl);\n  const workerFilePath = fileURLToPath(workerUrl);\n\n  const workerOptions: WorkerOptions = {\n    ...options,\n  };\n\n  // Add tsx loader for TypeScript in dev environment\n  if (isDevServerCore) {\n    workerOptions.execArgv = [...(options?.execArgv || []), \"--import\", \"tsx/esm\"];\n  }\n\n  return new Worker(workerFilePath, workerOptions);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,SAAgB,aACd,YACA,SACA,SACQ;CACR,MAAM,kBAAkB,IAAI,iBAAiB;CAM7C,MAAM,iBAAiB,cAAc,IADf,IAAI,GAAG,aADX,kBAAkB,QAAQ,SACW,OACV,CAAC;CAE9C,MAAM,gBAA+B,EACnC,GAAG,QACL;CAGA,IAAI,iBACF,cAAc,WAAW;EAAC,GAAI,SAAS,YAAY,CAAC;EAAI;EAAY;CAAS;CAG/E,OAAO,IAAI,OAAO,gBAAgB,aAAa;AACjD"}

package/esm/dev-server/dependency-graph.d.mts

@@ -0,0 +1,134 @@
+import { FileManager } from "./file-manager.mjs";
+
+//#region ../../@warlock.js/core/src/dev-server/dependency-graph.d.ts
+/**
+ * Dependency Graph
+ * Tracks bidirectional relationships between files:
+ * - dependencies: files that this file imports
+ * - dependents: files that import this file
+ *
+ * Each forward edge also carries an `isTypeOnly` flag so cycle detection
+ * can distinguish runtime cycles from ones formed purely by `import type`
+ * edges — the latter are erased by TypeScript and have no runtime effect.
+ */
+declare class DependencyGraph {
+  /**
+   * Map of file -> files it depends on (imports).
+   * Key: relative file path.
+   * Value: relative dependency path → `{ isTypeOnly }` for that edge.
+   */
+  private dependencies;
+  /**
+   * Map of file -> files that depend on it (importers)
+   * Key: relative file path
+   * Value: Set of relative file paths that import this file
+   */
+  private dependents;
+  /**
+   * Reference to the files map for accessing FileManager instances
+   * Used to read per-file typeOnlyDependencies during graph build.
+   */
+  private files;
+  /**
+   * Build dependency graph from FileManager map
+   */
+  build(files: Map<string, FileManager>): void;
+  /**
+   * Add a dependency relationship.
+   * If the edge already exists, the type-only flag is ANDed: any runtime
+   * statement between the two files makes the edge runtime permanently.
+   *
+   * @param file The file that has the dependency
+   * @param dependency The file being depended upon
+   * @param isTypeOnly Whether every reference from `file` to `dependency` is type-only
+   */
+  addDependency(file: string, dependency: string, isTypeOnly?: boolean): void;
+  /**
+   * Remove a dependency relationship
+   * @param file The file that has the dependency
+   * @param dependency The file being depended upon
+   */
+  removeDependency(file: string, dependency: string): void;
+  /**
+   * Remove all relationships for a file
+   * @param file The file to remove
+   */
+  removeFile(file: string): void;
+  /**
+   * Update dependencies for a file.
+   *
+   * Accepts the updated `Set<string>` of dependency paths; when the caller
+   * has per-edge type-only info, pass `typeOnlyDependencies` so the new
+   * edges get the correct flag. Missing flag defaults to runtime.
+   *
+   * @param file The file to update
+   * @param newDependencies New set of dependency paths
+   * @param typeOnlyDependencies Subset of `newDependencies` whose edges are type-only
+   */
+  updateFile(file: string, newDependencies: Set<string>, typeOnlyDependencies?: Set<string>): void;
+  /**
+   * Get files that this file depends on (imports)
+   * @param file The file to check
+   * @returns Set of files this file imports
+   */
+  getDependencies(file: string): Set<string>;
+  /**
+   * Check whether the edge `file → dependency` is type-only.
+   * Returns false if the edge does not exist.
+   */
+  isEdgeTypeOnly(file: string, dependency: string): boolean;
+  /**
+   * Get files that depend on this file (importers)
+   * @param file The file to check
+   * @returns Set of files that import this file
+   */
+  getDependents(file: string): Set<string>;
+  /**
+   * Get invalidation chain for a file
+   * Returns all files that need to be reloaded when this file changes
+   * Includes the file itself and all transitive dependents
+   * @param file The file that changed
+   * @returns Array of files to invalidate (in order)
+   */
+  getInvalidationChain(file: string): string[];
+  /**
+   * Detect circular dependencies in the dependency graph.
+   * Uses depth-first search to find cycles.
+   *
+   * Filtering rule (per-edge): a cycle is suppressed when **any** edge in
+   * the chain is type-only. TypeScript erases type-only imports entirely,
+   * so a single type-only edge breaks the cycle at runtime. Only warn when
+   * every edge is a runtime binding — that's the cycle that actually loops
+   * at load time.
+   *
+   * @returns Array of circular dependency chains (each chain is an array of file paths)
+   */
+  detectCircularDependencies(): string[][];
+  /**
+   * True iff every edge in the cycle is a runtime binding. The cycle array
+   * ends with a duplicate of its start (`[A, B, C, A]`) so we walk the
+   * consecutive pairs once — any type-only edge means TS erases the loop
+   * and there is no runtime cycle to report.
+   */
+  private isRuntimeCycle;
+  /**
+   * Display circular dependency warnings in a formatted, user-friendly way
+   * Shows each cycle with visual tree structure and helpful recommendations
+   */
+  private displayCircularDependencyWarnings;
+  /**
+   * Get statistics about the dependency graph
+   */
+  getStats(): {
+    totalFiles: number;
+    totalDependencies: number;
+    avgDependenciesPerFile: number;
+    maxDependencies: number;
+    maxDependents: number;
+    mostDependingFile: string;
+    mostDependedFile: string;
+  };
+}
+//#endregion
+export { DependencyGraph };
+//# sourceMappingURL=dependency-graph.d.mts.map

package/esm/dev-server/dependency-graph.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependency-graph.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/dev-server/dependency-graph.ts"],"mappings":";;;;;AAYA;;;;;;;;cAAa,eAAA;EA0L4B;;;;;EAAA,QApL/B,YAAA;EAkBY;;;;;EAAA,QAXZ,UAAA;EAiD+C;;;;EAAA,QA3C/C,KAAA;EA8EU;;;EAzEX,KAAA,CAAM,KAAA,EAAO,GAAA,SAAY,WAAA;EA2G9B;;;;;;;;;EArEK,aAAA,CAAc,IAAA,UAAc,UAAA,UAAoB,UAAA;EA4HlC;;;;;EAlGd,gBAAA,CAAiB,IAAA,UAAc,UAAA;EAwM9B;;;;EA/LD,UAAA,CAAW,IAAA;;;;;;;;;;;;EAgCX,UAAA,CACL,IAAA,UACA,eAAA,EAAiB,GAAA,UACjB,oBAAA,GAAsB,GAAA;;;;;;EA+BjB,eAAA,CAAgB,IAAA,WAAe,GAAA;;;;;EAc/B,cAAA,CAAe,IAAA,UAAc,UAAA;;;;;;EAS7B,aAAA,CAAc,IAAA,WAAe,GAAA;;;;;;;;EAW7B,oBAAA,CAAqB,IAAA;;;;;;;;;;;;;EA+BrB,0BAAA,CAAA;;;;;;;UA2CC,cAAA;;;;;UAiBA,iCAAA;;;;EAgGD,QAAA,CAAA"}