DEV Community: Samuel Karani

arrays-sugar provides async versions of javascript array methods with predicate callbacks

Samuel Karani — Thu, 31 Jul 2025 20:21:19 +0000

TLDR: This article introduces the arrays-sugar library: https://github.com/samuelkarani/arrays-sugar

Why won't this work correctly in javascript?

const array = [1, 7, 3]
array.every(async (number) => number > 1) // returns true instead of false
array.filter(async (number) => number > 1) // returns [1, 7, 3] instead of ?
array.find(async (number) => number > 1) // returns 1 instead of ?
array.findIndex(async (number) => number > 1) // returns 0 instead of ?
array.some(async (number) => number > 7) // returns true instead of ?

All these return incorrect values because the async makes the callback return a promise which always returns truthy when evaluated.

While map is happy to give you as many promises as you want:

array.map(async (number) => number * 2)
// [ Promise { 2 }, Promise { 14 }, Promise { 6 } ]

And reduce works with both promise and async/await callbacks:

const numbers = [1, 2, 3, 4, 5];

const sum1 = await numbers.reduce((accumulator, number) => {
  return accumulator.then(value => value + number)
}, Promise.resolve(0));
// sum1 is 15

const sum2 = await numbers.reduce(async (accumulator, number) => {
  await sleep(10) // wraps setTimeout
  return (await accumulator) + number;
}, Promise.resolve(0))
// sum2 is 15

Introducing my new library: arrays-sugar - a set of async versions of every, filter, find, findIndex, some

Build with Typescript for the Browser or Node.js

Each function has 2 or 3 versions:

The default version that is concurrent and uses Promise.allSettled internally:

// both are equivalent
   [1, 2, 3].every(async (number) => number === 2) === true
   [1, 2, 3].everyConcurrent(async (number) => number === 2) === true

The optimized version which may not iterate the entire array and requires that the predicate throws for falsy values instead of returning false. This is available for all functions except filter which has to go through the whole array.

const result = await findOptimized(array, async (item) => {
      if (item <= 1) {
        throw new Error("error");
      }
      return true;
    });

The serial version that iterates each item one at a time (slow) - incase this is what you want to do.

const result = await findIndexSerial(array, async (item) => {
      await sleep(100);
      return item > 1;
    });

That's all
Thanks for reading. I welcome your input, suggestions, feedback.
Github link: https://github.com/samuelkarani/arrays-sugar
NPM link: https://www.npmjs.com/package/arrays-sugar

One more thing
You can check out the related library AI Sugar where these functions are used internally to work with AI APIs.

zod-sugar is just ‘zod backwards’ or “zod in reverse”

Samuel Karani — Thu, 31 Jul 2025 19:36:18 +0000

TLDR: This article introduces the zod-sugar library: https://github.com/samuelkarani/zod-sugar

When building my newly released ai-sugar library, I came across a use case where I needed to create a zod schema from a value - instead of the usual case where you define your schema then parse your value with it. So I made I library for it and released it for the world on NPM.

Here's example of how it works:

import { createZod } from "zod-sugar";

const object = {
   foo: "bar",
   bar: 1,
   baz: [1, 2, 3],
   qux: { foo: "bar" },
}
const schema = createZod(object);
// schema is a ZodObject
const result = schema.safeParse(object);
// result.success === true

It works with common javascript values: null, undefined, boolean, number, bigint, string, symbol, array, object:

createZod(null) // ZodNull

createZod(undefined) // ZodUndefined

createZod(1) // ZodNumber

createZod("foo") // ZodString

createZod(false) // ZodBoolean

createZod(Symbol("foo")) // ZodSymbol

createZod(BigInt(1)) // ZodBigInt

createZod([1, 2, 3]) // ZodArray

createZod({ foo: "bar", baz: 1 }) // ZodObject

createZod({
 string: "bar",
 number: 1,
 array: [1, 2, 3],
 bigint: BigInt(9007199254740991),
 object: {
    number: 0,
    boolean: false,
    object: {
       string: "bar",
       null: null,
       [Symbol("foo")]: "bar",
    },
    array: ["1", "2", "3"],
 },
undefined: undefined,
}) // ZodObject

To install it simply:

npm install zod-sugar
yarn add zod-sugar
pnpm install zod-sugar

Links
AI Sugar is the related library where these functions are used internally to work with AI APIs: https://github.com/samuelkarani/ai-sugar
Github link: https://github.com/samuelkarani/zod-sugar
NPM link: https://www.npmjs.com/package/zod-sugar

How to setup Vercel AI Function Streaming with CORS support

Samuel Karani — Thu, 31 Jul 2025 19:02:04 +0000

Vercel seems to have abandoned or deprioritized their serverless functions offering (outside Next.js) because I couldn’t find any official documentation for setting up function streaming with CORS enabled.

Eventually this ended up being quite a hassle to figure out, so I decided to make this snippet for anyone who needs it.

import { openai } from "@ai-sdk/openai";
import { streamText } from "ai";

export function OPTIONS() {
  return new Response("OK", {
    status: 200,
    headers: {
      "Access-Control-Allow-Credentials": "true",
      "Access-Control-Allow-Origin": "*",
      "Access-Control-Allow-Methods": "GET,OPTIONS,PATCH,DELETE,POST,PUT",
      "Access-Control-Allow-Headers":
        "X-CSRF-Token, X-Requested-With, Accept, Accept-Version, Content-Length, Content-MD5, Content-Type, Date, X-Api-Version",
    },
  });
}

export async function GET() {
  const response = streamText({
    model: openai("gpt-4o-mini"),
    messages: [{ role: "user", content: "Write a short poem" }],
  });
  return response.toTextStreamResponse({
    headers: {
      "Content-Type": "text/event-stream",
      "Access-Control-Allow-Credentials": "true",
      "Access-Control-Allow-Origin": "*",
      "Access-Control-Allow-Methods": "GET,OPTIONS,PATCH,DELETE,POST,PUT",
      "Access-Control-Allow-Headers":
        "X-CSRF-Token, X-Requested-With, Accept, Accept-Version, Content-Length, Content-MD5, Content-Type, Date, X-Api-Version",
    },
  });
}