codeweaver 3.0.2 → 3.0.5

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "codeweaver",
-  "version": "3.0.2",
+  "version": "3.0.5",
   "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,6 @@
 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,24 +15,22 @@ 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];

package/src/utilities/conversion.ts

@@ -1,5 +1,6 @@
 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.
@@ -131,13 +132,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) {

package/src/utilities/parallel/parallel.ts

@@ -2,6 +2,21 @@ 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 +28,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]
  */
@@ -117,11 +134,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