codeweaver 3.0.2 → 3.0.6

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "codeweaver",
-  "version": "3.0.2",
+  "version": "3.0.6",
   "main": "src/main.ts",
   "bin": {
-    "codeweaver": "./command.js"
+    "codeweaver": "command.js"
   },
   "scripts": {
     "start": "nodemon -r tsconfig-paths/register src/main.ts",

package/src/routers/products/product.controller.ts

@@ -161,7 +161,7 @@ export default class ProductController {
     }
     const product = await this.get(id);
     if (product != null) {
-      await assign(updateData, product, ZodProduct);
+      await assign(product, updateData, ZodProduct);
       await productCache.delete(updateData.id.toString());
       await productsCache.delete("key");
     } else {

package/src/utilities/assignment.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { ResponseError } from "./error-handling";
+import { parallelMap } from "./parallel/parallel";
 
 /**
  * Strictly assign obj (type T1) to T2 using a Zod schema.
@@ -14,33 +14,28 @@ import { ResponseError } from "./error-handling";
  * @returns T2 representing the destination after assignment
  */
 export default async function assign<T1 extends object, T2 extends object>(
-  source: T1,
   destination: T2,
-  schema?: z.ZodObject<any>
+  source: T1,
+  destinationSchema?: z.ZodObject<any>
 ): Promise<T2> {
-  let keys = Object.keys(schema?.shape ?? destination);
+  let keys = Object.keys(destinationSchema?.shape ?? destination);
 
   // Iterate schema keys
-  await Promise.all(
-    keys.map(async (key) => {
-      if (source.hasOwnProperty(key)) {
-        (destination as any)[key] = (source as any)[key];
-      }
-    })
-  );
+  await parallelMap(keys, async (key) => {
+    if (source.hasOwnProperty(key)) {
+      (destination as any)[key] = (source as any)[key];
+    }
+  });
 
-  if (schema != null) {
+  if (destinationSchema != null) {
     // Validate using the schema on the subset (this will also coerce if the schema has transforms)
-    const parseResult = await schema.safeParseAsync(destination);
+    const parseResult = await destinationSchema.safeParseAsync(destination);
     if (parseResult.success == false) {
       // Build a descriptive error message from the first issue
       const issue = parseResult.error.issues?.[0];
       const path = issue?.path?.length ? issue.path.join(".") : "value";
       const message = issue?.message ?? "Schema validation failed";
-      throw new ResponseError(
-        `Validation failed for "${path}": ${message}`,
-        500
-      );
+      throw new Error(`Validation failed for "${path}": ${message}`);
     }
   }
 

package/src/utilities/conversion.ts

@@ -1,5 +1,5 @@
 import { z, ZodRawShape } from "zod";
-import { ResponseError } from "./error-handling";
+import { parallelMap } from "./parallel/parallel";
 
 /**
  * Helper: normalize and validate a numeric string for integer parsing.
@@ -41,10 +41,7 @@ export function stringToInteger(input: string): number {
   try {
     return parseIntegerStrict(input);
   } catch {
-    throw new ResponseError(
-      "The input parameter must be a valid integer.",
-      400
-    );
+    throw new Error("The input parameter must be a valid integer.");
   }
 }
 
@@ -71,9 +68,8 @@ export function stringToBoolean(input: string): boolean {
     return false;
   }
 
-  throw new ResponseError(
-    "The input parameter must be a boolean (e.g., true/false, 1/0).",
-    400
+  throw new Error(
+    "The input parameter must be a boolean (e.g., true/false, 1/0)."
   );
 }
 
@@ -98,7 +94,7 @@ export function stringToNumber(input: string): number {
 
     return n;
   } catch {
-    throw new ResponseError("The input parameter must be a valid number.", 400);
+    throw new Error("The input parameter must be a valid number.");
   }
 }
 
@@ -121,7 +117,7 @@ export async function convert<T1 extends object, T2 extends object>(
   // Derive the runtime keys from the schema's shape
   const shape = (schema as any)._def?.shape as ZodRawShape | undefined;
   if (!shape) {
-    throw new ResponseError("Provided schema has no shape.", 500);
+    throw new Error("Provided schema has no shape.");
   }
 
   const keysSchema = Object.keys(shape) as Array<keyof any>;
@@ -131,13 +127,11 @@ export async function convert<T1 extends object, T2 extends object>(
   const candidate: any = {};
 
   // Iterate schema keys
-  await Promise.all(
-    keysSchema.map(async (key) => {
-      if ((data as any).hasOwnProperty(key)) {
-        candidate[key] = (data as any)[key];
-      }
-    })
-  );
+  await parallelMap(keysSchema, async (key) => {
+    if ((data as any).hasOwnProperty(key)) {
+      candidate[key] = (data as any)[key];
+    }
+  });
 
   // Validate against the schema
   if (ignoreValidation) {
@@ -151,10 +145,7 @@ export async function convert<T1 extends object, T2 extends object>(
       }));
 
       // You can log issues or throw a structured error
-      throw new ResponseError(
-        `Validation failed: ${JSON.stringify(issues)}`,
-        500
-      );
+      throw new Error(`Validation failed: ${JSON.stringify(issues)}`);
     }
 
     // Return the validated data typed as T2

package/src/utilities/error-handling.ts

@@ -45,7 +45,9 @@ export class ResponseError extends Error {
     super(message);
 
     // If a custom stack is provided, you might assign it; otherwise, the runtime stack will be used.
-    if (stack) this.stack = stack;
+    if (stack) {
+      this.stack = stack;
+    }
   }
 }
 

package/src/utilities/parallel/chanel.ts

@@ -1,5 +1,3 @@
-import { ResponseError } from "../error-handling";
-
 /**
  * Event callback type for channel send event.
  * @template T - Type of the value sent through the channel.
@@ -38,7 +36,7 @@ export class Channel<T> {
    */
   public async send(value: T): Promise<void> {
     if (this.closed) {
-      throw new ResponseError("Channel is closed", 500);
+      throw new Error("Channel is closed");
     }
     if (this.receivers.length > 0) {
       const receiver = this.receivers.shift()!;
@@ -62,7 +60,7 @@ export class Channel<T> {
       return this.queue.shift()!;
     }
     if (this.closed) {
-      throw new ResponseError("Channel is closed", 500);
+      throw new Error("Channel is closed");
     }
     return await new Promise<T>((resolve) => {
       this.receivers.push(resolve);

package/src/utilities/parallel/parallel.ts

@@ -1,7 +1,20 @@
-import { ResponseError } from "../error-handling";
-import path from "path";
 import { WorkerPool } from "./worker-pool";
 
+/**
+ * Creates a setter function that, when invoked, rebinds the captured
+ * destination binding to the provided source value.
+ *
+ * @template T - The type of both `destination` and `source`, constrained to object types.
+ * @param {T} destination - The destination value (captured by the closure).
+ * @param {T} source - The source value to which `destination` will be rebound when the returned function runs.
+ * @returns {() => void} A function that, when called, rebinds the captured `destination` to `source`.
+ */
+export function set<T extends object>(destination: T, source: T): () => void {
+  return () => {
+    destination = source;
+  };
+}
+
 /**
  * Executes multiple asynchronous or synchronous tasks in parallel and returns their results as an array.
  *
@@ -13,7 +26,9 @@ import { WorkerPool } from "./worker-pool";
  * const results = await parallel(
  *   () => fetchUser(1),
  *   () => fetchUser(2),
- *   () => fetchUser(3)
+ *   fetchProduct,
+ *   set(user.id, 1),
+ *   set(user.name, "Bob")
  * );
  * console.log(results); // [user1, user2, user3]
  */
@@ -60,11 +75,11 @@ export async function parallelMapWithConcurrencyLevel<T, U>(
   concurrencyLevel: number = Infinity
 ): Promise<U[]> {
   if (!Array.isArray(items)) {
-    throw new ResponseError("Items must be an array", 400);
+    throw new TypeError("Items must be an array");
   }
 
   if (concurrencyLevel <= 0) {
-    throw new ResponseError("Concurrency must be greater than 0", 500);
+    throw new Error("Concurrency must be greater than 0");
   }
 
   // If concurrency is not finite, use the simple Promise.all approach
@@ -117,11 +132,11 @@ export async function parallelCpuMap<T, R>(
     throw new Error("concurrency must be greater than 0");
   }
 
-  // Worker pool setup
-  const workerPath = path.resolve(__dirname, mapperWorkerFilePath);
-
   // Instantiate a concrete pool
-  const workerPool = new WorkerPool<T, R>(workerPath, concurrencyLevel);
+  const workerPool = new WorkerPool<T, R>(
+    mapperWorkerFilePath,
+    concurrencyLevel
+  );
 
   try {
     // Dispatch all items and collect results in order

package/src/utilities/parallel/worker-pool.ts

@@ -1,6 +1,5 @@
 import { Worker } from "worker_threads";
 import os from "os";
-import { ResponseError } from "../error-handling";
 
 export type Task<T> = { id: number; payload: T };
 export type Result<R> = { id: number; result?: R; error?: string };
@@ -28,9 +27,7 @@ export class WorkerPool<T, R> {
         if (code !== 0) {
           // Notify all pending promises about the exit
           for (const [, p] of this.pending) {
-            p.reject(
-              new ResponseError(`Worker ${i} exited with code ${code}`, 500)
-            );
+            p.reject(new Error(`Worker ${i} exited with code ${code}`));
           }
           this.pending.clear();
         }
@@ -56,10 +53,7 @@ export class WorkerPool<T, R> {
     // This simple version broadcasts the error to all pending tasks for safety.
     for (const [id, entry] of this.pending) {
       entry.reject(
-        new ResponseError(
-          `Worker ${workerIndex} error: ${err?.message ?? err}`,
-          500
-        )
+        new Error(`Worker ${workerIndex} error: ${err?.message ?? err}`)
       );
     }
     this.pending.clear();
@@ -77,8 +71,7 @@ export class WorkerPool<T, R> {
 
   // Map all items using a round-robin distribution across workers
   async mapAll(items: T[]): Promise<R[]> {
-    if (!Array.isArray(items))
-      throw new ResponseError("Items must be an array", 400);
+    if (!Array.isArray(items)) throw new Error("Items must be an array");
     const results: R[] = new Array(items.length);
 
     const workerCount = this.workers.length;