flowli 0.2.1

package/dist/runtime/resolve-context.js

@@ -0,0 +1,6 @@
+export function createContextResolver(context) {
+    if (typeof context === "function") {
+        return async () => Promise.resolve(context());
+    }
+    return async () => context;
+}

package/dist/runtime/validate.d.ts

@@ -0,0 +1,2 @@
+import type { InferOutput, StandardSchemaV1 } from "../core/types.js";
+export declare function validateWithSchema<TSchema extends StandardSchemaV1<any, any>>(schema: TSchema, value: unknown, label: string): Promise<InferOutput<TSchema>>;

package/dist/runtime/validate.js

@@ -0,0 +1,15 @@
+import { FlowliValidationError } from "../core/errors.js";
+export async function validateWithSchema(schema, value, label) {
+    const result = (await schema["~standard"].validate(value));
+    if (isFailure(result)) {
+        const issueSummary = result.issues.map((issue) => issue.message).join(", ");
+        throw new FlowliValidationError(`${label} validation failed: ${issueSummary || "unknown validation issue"}`, result.issues);
+    }
+    return result.value;
+}
+function isFailure(result) {
+    return Boolean(result &&
+        typeof result === "object" &&
+        "issues" in result &&
+        Array.isArray(result.issues));
+}

package/dist/strategies/delay.d.ts

@@ -0,0 +1,2 @@
+import type { AnyJobDefinition, DelayValue, FlowliContextRecord, FlowliRuntimeInternals, JobDefaults, JobReceipt, PersistedInvocationOptions } from "../core/types.js";
+export declare function delayStrategy<TJob extends AnyJobDefinition, TContext extends FlowliContextRecord>(job: TJob, internals: FlowliRuntimeInternals<Record<string, TJob>, TContext>, defaults: JobDefaults, now: number, delay: DelayValue, input: unknown, options?: PersistedInvocationOptions<unknown>): Promise<JobReceipt>;

package/dist/strategies/delay.js

@@ -0,0 +1,32 @@
+import { FlowliStrategyError } from "../core/errors.js";
+import { parseDelay } from "../driver/duration.js";
+import { createPersistedJobRecord } from "../driver/records.js";
+import { createJobId } from "../driver/scheduling.js";
+import { validateWithSchema } from "../runtime/validate.js";
+export async function delayStrategy(job, internals, defaults, now, delay, input, options) {
+    const driver = requireDriver(internals.driver, job.name, "delay");
+    const validatedInput = await validateWithSchema(job.input, input, `${job.name} input`);
+    const validatedMeta = job.meta
+        ? await validateWithSchema(job.meta, options?.meta, `${job.name} meta`)
+        : undefined;
+    const scheduledFor = now + parseDelay(delay);
+    const record = createPersistedJobRecord({
+        id: createJobId(),
+        name: job.name,
+        input: validatedInput,
+        meta: validatedMeta,
+        scheduledFor,
+        maxAttempts: options?.maxAttempts ?? defaults.maxAttempts ?? 1,
+        ...((options?.backoff ?? defaults.backoff)
+            ? { backoff: options?.backoff ?? defaults.backoff }
+            : {}),
+        now,
+    });
+    return driver.enqueue(record);
+}
+function requireDriver(driver, jobName, strategy) {
+    if (!driver) {
+        throw new FlowliStrategyError(`Job "${jobName}" cannot use ${strategy}() without a configured driver.`);
+    }
+    return driver;
+}

package/dist/strategies/enqueue.d.ts

@@ -0,0 +1,2 @@
+import type { AnyJobDefinition, FlowliContextRecord, FlowliRuntimeInternals, JobDefaults, JobReceipt, PersistedInvocationOptions } from "../core/types.js";
+export declare function enqueueStrategy<TJob extends AnyJobDefinition, TContext extends FlowliContextRecord>(job: TJob, internals: FlowliRuntimeInternals<Record<string, TJob>, TContext>, defaults: JobDefaults, now: number, input: unknown, options?: PersistedInvocationOptions<unknown>): Promise<JobReceipt>;

package/dist/strategies/enqueue.js

@@ -0,0 +1,30 @@
+import { FlowliStrategyError } from "../core/errors.js";
+import { createPersistedJobRecord } from "../driver/records.js";
+import { createJobId } from "../driver/scheduling.js";
+import { validateWithSchema } from "../runtime/validate.js";
+export async function enqueueStrategy(job, internals, defaults, now, input, options) {
+    const driver = requireDriver(internals.driver, job.name, "enqueue");
+    const validatedInput = await validateWithSchema(job.input, input, `${job.name} input`);
+    const validatedMeta = job.meta
+        ? await validateWithSchema(job.meta, options?.meta, `${job.name} meta`)
+        : undefined;
+    const record = createPersistedJobRecord({
+        id: createJobId(),
+        name: job.name,
+        input: validatedInput,
+        meta: validatedMeta,
+        scheduledFor: now,
+        maxAttempts: options?.maxAttempts ?? defaults.maxAttempts ?? 1,
+        ...((options?.backoff ?? defaults.backoff)
+            ? { backoff: options?.backoff ?? defaults.backoff }
+            : {}),
+        now,
+    });
+    return driver.enqueue(record);
+}
+function requireDriver(driver, jobName, strategy) {
+    if (!driver) {
+        throw new FlowliStrategyError(`Job "${jobName}" cannot use ${strategy}() without a configured driver.`);
+    }
+    return driver;
+}

package/dist/strategies/run.d.ts

@@ -0,0 +1,2 @@
+import type { AnyJobDefinition, FlowliContextRecord, FlowliRuntimeInternals, JobDefaults, JobMeta, JobResult } from "../core/types.js";
+export declare function runStrategy<TJob extends AnyJobDefinition, TContext extends FlowliContextRecord>(job: TJob, internals: FlowliRuntimeInternals<Record<string, TJob>, TContext>, _defaults: JobDefaults, input: unknown, meta: JobMeta<TJob> | undefined): Promise<JobResult<TJob>>;

package/dist/strategies/run.js

@@ -0,0 +1,10 @@
+import { invokeHandler } from "../runtime/invoke-handler.js";
+import { validateWithSchema } from "../runtime/validate.js";
+export async function runStrategy(job, internals, _defaults, input, meta) {
+    const validatedInput = await validateWithSchema(job.input, input, `${job.name} input`);
+    const validatedMeta = job.meta
+        ? await validateWithSchema(job.meta, meta, `${job.name} meta`)
+        : undefined;
+    const context = await internals.context();
+    return invokeHandler(job, validatedInput, context, validatedMeta);
+}

package/dist/strategies/schedule.d.ts

@@ -0,0 +1,2 @@
+import type { AnyJobDefinition, FlowliContextRecord, FlowliRuntimeInternals, JobDefaults, ScheduleInvocation, ScheduleReceipt } from "../core/types.js";
+export declare function scheduleStrategy<TJob extends AnyJobDefinition, TContext extends FlowliContextRecord>(job: TJob, internals: FlowliRuntimeInternals<Record<string, TJob>, TContext>, defaults: JobDefaults, now: number, invocation: ScheduleInvocation<unknown, unknown>): Promise<ScheduleReceipt>;

package/dist/strategies/schedule.js

@@ -0,0 +1,33 @@
+import { FlowliStrategyError } from "../core/errors.js";
+import { createScheduleRecord } from "../driver/records.js";
+import { deriveScheduleKey, getNextCronRun, validateCron, } from "../driver/scheduling.js";
+import { validateWithSchema } from "../runtime/validate.js";
+export async function scheduleStrategy(job, internals, defaults, now, invocation) {
+    const driver = requireDriver(internals.driver, job.name, "schedule");
+    validateCron(invocation.cron);
+    const validatedInput = await validateWithSchema(job.input, invocation.input, `${job.name} input`);
+    const validatedMeta = job.meta
+        ? await validateWithSchema(job.meta, invocation.meta, `${job.name} meta`)
+        : undefined;
+    const key = invocation.key ??
+        deriveScheduleKey(job.name, invocation.cron, validatedInput);
+    const nextRunAt = getNextCronRun(invocation.cron, now);
+    const record = createScheduleRecord({
+        key,
+        name: job.name,
+        cron: invocation.cron,
+        input: validatedInput,
+        meta: validatedMeta,
+        maxAttempts: defaults.maxAttempts ?? 1,
+        ...(defaults.backoff ? { backoff: defaults.backoff } : {}),
+        nextRunAt,
+        now,
+    });
+    return driver.registerSchedule(record);
+}
+function requireDriver(driver, jobName, strategy) {
+    if (!driver) {
+        throw new FlowliStrategyError(`Job "${jobName}" cannot use ${strategy}() without a configured driver.`);
+    }
+    return driver;
+}

package/dist/tanstack-start.d.ts

@@ -0,0 +1 @@
+export { type TanStackStartRouteContext, type TanStackStartRouteHandler, type TanStackStartRouteHandlerArgs, type TanStackStartRouteParams, type TanStackStartServerFnHandler, type TanStackStartServerFnTools, tanstackStartRoute, tanstackStartServerFn, } from "./integrations/tanstack-start.js";

package/dist/tanstack-start.js

@@ -0,0 +1,4 @@
+export {
+  tanstackStartServerFn,
+  tanstackStartRoute
+};

package/jsr.json

@@ -0,0 +1,26 @@
+{
+  "$schema": "https://jsr.io/schema/config-file.v1.json",
+  "name": "@alialnaghmoush/flowli",
+  "version": "0.2.1",
+  "exports": {
+    ".": "./src/index.ts",
+    "./ioredis": "./src/ioredis.ts",
+    "./redis": "./src/redis.ts",
+    "./bun-redis": "./src/bun-redis.ts",
+    "./next": "./src/next.ts",
+    "./tanstack-start": "./src/tanstack-start.ts",
+    "./hono": "./src/hono.ts",
+    "./runner": "./src/runner.ts"
+  },
+  "include": [
+    "README.md",
+    "src/**/*.ts",
+    "package.json"
+  ],
+  "exclude": [
+    "dist/",
+    "node_modules/",
+    "test/",
+    "type-tests/"
+  ]
+}

package/package.json

@@ -0,0 +1,135 @@
+{
+  "name": "flowli",
+  "version": "0.2.1",
+  "description": "Flowli is a jobs runtime with a code-first API, first-class execution strategies, runtime-scoped context injection, and pluggable Redis drivers.",
+  "keywords": [
+    "jobs",
+    "queue",
+    "redis",
+    "nextjs",
+    "tanstack-start",
+    "typescript",
+    "background-jobs",
+    "scheduler"
+  ],
+  "homepage": "https://github.com/alialnaghmoush/flowli#readme",
+  "bugs": {
+    "url": "https://github.com/alialnaghmoush/flowli/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/alialnaghmoush/flowli.git"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "sideEffects": false,
+  "packageManager": "bun@1.3.10",
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "jsr.json"
+  ],
+  "scripts": {
+    "build:js": "bun build ./src/index.ts ./src/ioredis.ts ./src/redis.ts ./src/bun-redis.ts ./src/next.ts ./src/tanstack-start.ts ./src/hono.ts ./src/runner.ts --outdir dist --root ./src --target node --format esm",
+    "build:types": "tsc -p tsconfig.build.json",
+    "build": "bun run build:js && bun run build:types",
+    "format": "biome format --write .",
+    "lint": "biome check .",
+    "check": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.type-tests.json --noEmit",
+    "prepack": "bun run verify",
+    "pack:npm": "npm pack --dry-run --cache ./.npm-cache",
+    "publish:npm-d": "npm publish --dry-run --cache ./.npm-cache",
+    "publish:npm": "npm publish --cache ./.npm-cache",
+    "publish:jsr-d": "npx jsr publish --dry-run",
+    "publish:jsr": "npx jsr publish",
+    "publish:all-d": "bun run publish:npm-d && bun run publish:jsr-d",
+    "publish:all": "bun run publish:npm && bun run publish:jsr",
+    "docker:up": "docker compose up -d",
+    "docker:down": "docker compose down -v",
+    "test:redis:docker": "FLOWLI_REDIS_URL=redis://127.0.0.1:6379/0 bun run test:redis",
+    "test": "bun test",
+    "test:redis": "bun test test/redis.integration.test.ts",
+    "verify:publish": "bun run pack:npm",
+    "verify": "bun run lint && bun run check && bun run build && bun test"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.7",
+    "@types/bun": "latest",
+    "ioredis": "^5.10.0",
+    "redis": "^5.11.0",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "@tanstack/react-start": "^1.0.0-rc || ^1",
+    "ioredis": "",
+    "next": "^15 || ^16",
+    "redis": "",
+    "typescript": "^5",
+    "valibot": "^1.3.0",
+    "zod": "^4.3.6"
+  },
+  "peerDependenciesMeta": {
+    "@tanstack/react-start": {
+      "optional": true
+    },
+    "ioredis": {
+      "optional": true
+    },
+    "next": {
+      "optional": true
+    },
+    "redis": {
+      "optional": true
+    },
+    "typescript": {
+      "optional": true
+    },
+    "valibot": {
+      "optional": true
+    },
+    "zod": {
+      "optional": true
+    }
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./ioredis": {
+      "types": "./dist/ioredis.d.ts",
+      "import": "./dist/ioredis.js"
+    },
+    "./redis": {
+      "types": "./dist/redis.d.ts",
+      "import": "./dist/redis.js"
+    },
+    "./bun-redis": {
+      "types": "./dist/bun-redis.d.ts",
+      "import": "./dist/bun-redis.js"
+    },
+    "./next": {
+      "types": "./dist/next.d.ts",
+      "import": "./dist/next.js"
+    },
+    "./tanstack-start": {
+      "types": "./dist/tanstack-start.d.ts",
+      "import": "./dist/tanstack-start.js"
+    },
+    "./hono": {
+      "types": "./dist/hono.d.ts",
+      "import": "./dist/hono.js"
+    },
+    "./runner": {
+      "types": "./dist/runner.d.ts",
+      "import": "./dist/runner.js"
+    }
+  }
+}