better-cf 1.0.0 → 2.0.0

package/dist/types-C1mNTuC-.d.ts

@@ -0,0 +1,239 @@
+import { z } from 'zod';
+
+interface BetterCfGeneratedBindings {
+}
+interface BetterCfGeneratedApi {
+}
+interface BetterCfAutoEnv extends BetterCfGeneratedBindings {
+    [binding: string]: unknown;
+}
+type RuntimeEnv<E> = E & BetterCfGeneratedBindings;
+type RuntimeApi = BetterCfGeneratedApi;
+type Duration = number | `${number}s` | `${number}m` | `${number}h`;
+type ContentType = 'json' | 'text' | 'bytes' | 'v8';
+interface SendOptions {
+    delay?: Duration;
+    contentType?: ContentType;
+}
+interface SendBatchEntry<T> {
+    data: T;
+    delay?: Duration;
+    contentType?: ContentType;
+}
+interface BaseExecutionContext<E> {
+    env: RuntimeEnv<E>;
+    executionCtx: ExecutionContext;
+    api: RuntimeApi;
+}
+interface WorkerContext<E> extends BaseExecutionContext<E> {
+}
+interface QueueMessageContext<E> extends BaseExecutionContext<E> {
+    message: {
+        id: string;
+        timestamp: Date;
+        attempts: number;
+        queue: string;
+    };
+}
+interface QueueBatchContext<E> extends BaseExecutionContext<E> {
+    batch: {
+        queue: string;
+        receivedAt: Date;
+        firstMessageTimestamp?: Date;
+        ackAll: () => void;
+        retryAll: (options?: {
+            delaySeconds?: number;
+        }) => void;
+    };
+}
+interface DurableBaseContext<E> extends BaseExecutionContext<E> {
+    state: DurableObjectState;
+    storage: DurableObjectStorage;
+    sql: DurableObjectStorage['sql'];
+}
+interface DurableFetchContext<E> extends DurableBaseContext<E> {
+    request: Request;
+}
+interface DurableAlarmContext<E> extends DurableBaseContext<E> {
+    alarmInfo: AlarmInvocationInfo;
+}
+interface DurableWebSocketConnectContext<E, TAttachment> extends DurableBaseContext<E> {
+    request: Request;
+    client: WebSocket;
+    server: WebSocket;
+    accept: (options?: {
+        tags?: string[];
+        attachment?: TAttachment;
+    }) => void;
+}
+interface DurableWebSocketEventContext<E, TAttachment> extends DurableBaseContext<E> {
+    socket: WebSocket;
+    attachment: TAttachment | undefined;
+}
+interface QueueCommonConfig {
+    retry?: number;
+    retryDelay?: Duration;
+    deadLetter?: string;
+    deliveryDelay?: Duration;
+    visibilityTimeout?: Duration;
+    batch?: {
+        maxSize?: number;
+        timeout?: Duration;
+        maxConcurrency?: number;
+    };
+}
+interface PullConsumerConfig {
+    type: 'http_pull';
+    visibilityTimeout?: Duration;
+}
+interface QueueConfig<TSchema extends z.ZodTypeAny> extends QueueCommonConfig {
+    args: TSchema;
+    description?: string;
+    consumer?: {
+        type?: 'worker';
+    } | PullConsumerConfig;
+}
+interface QueueJobConfig<TSchema extends z.ZodTypeAny> {
+    args: TSchema;
+    description?: string;
+}
+type MultiJobQueueConfig<TConfig extends Record<string, unknown>> = QueueCommonConfig & {
+    description?: string;
+    consumer?: never;
+    args?: never;
+} & TConfig;
+interface QueueMessageConsumerConfig<E, TMessage> {
+    description?: string;
+    handler: (ctx: QueueMessageContext<E>, args: TMessage) => Promise<void> | void;
+    failure?: (ctx: QueueMessageContext<E>, args: TMessage | null, error: Error) => Promise<void> | void;
+}
+interface QueueBatchConsumerConfig<E, TMessage> {
+    description?: string;
+    handler: (ctx: QueueBatchContext<E>, args: ConsumerBatchEntry<TMessage>[]) => Promise<void> | void;
+    failure?: (ctx: QueueBatchContext<E>, args: ConsumerBatchEntry<TMessage>[] | null, error: Error) => Promise<void> | void;
+}
+interface ConsumerBatchEntry<T> {
+    data: T;
+    id: string;
+    timestamp: Date;
+    attempts: number;
+}
+interface DurableObjectConfig<TKeySchema extends z.ZodTypeAny> {
+    name: string;
+    key: TKeySchema;
+    version?: number;
+    description?: string;
+}
+interface DurableFnConfig<E, TArgsSchema extends z.ZodTypeAny, TReturn> {
+    args: TArgsSchema;
+    returns?: z.ZodType<TReturn>;
+    description?: string;
+    handler: (ctx: DurableBaseContext<E>, args: z.infer<TArgsSchema>) => Promise<TReturn> | TReturn;
+}
+interface DurableFetchConfig<E> {
+    description?: string;
+    handler: (ctx: DurableFetchContext<E>) => Promise<Response> | Response;
+}
+interface DurableAlarmConfig<E> {
+    description?: string;
+    handler: (ctx: DurableAlarmContext<E>) => Promise<void> | void;
+}
+interface DurableInitConfig<E> {
+    description?: string;
+    handler: (ctx: DurableBaseContext<E>) => Promise<void> | void;
+}
+interface DurableWebSocketConfig<E, TAttachment = unknown> {
+    description?: string;
+    connect?: (ctx: DurableWebSocketConnectContext<E, TAttachment>) => Promise<Response | void> | Response | void;
+    message?: (ctx: DurableWebSocketEventContext<E, TAttachment>, message: string | ArrayBuffer) => Promise<void> | void;
+    close?: (ctx: DurableWebSocketEventContext<E, TAttachment>, code: number, reason: string, wasClean: boolean) => Promise<void> | void;
+    error?: (ctx: DurableWebSocketEventContext<E, TAttachment>, error: unknown) => Promise<void> | void;
+    serializeAttachment?: (attachment: TAttachment) => unknown;
+    hydrateAttachment?: (attachment: unknown) => TAttachment;
+}
+interface WorkerConfig<E> {
+    fetch: (request: Request, ctx: WorkerContext<E>) => Promise<Response>;
+    scheduled?: (event: ScheduledEvent, ctx: WorkerContext<E>) => Promise<void>;
+}
+interface WorkerEntrypoint<E> {
+    fetch(request: Request, env: E, executionCtx: ExecutionContext): Promise<Response>;
+    scheduled?: (event: ScheduledEvent, env: E, executionCtx: ExecutionContext) => Promise<void>;
+}
+interface QueueHandle<E, TMessage> {
+    message(config: QueueMessageConsumerConfig<E, TMessage>): QueueConsumerRef<TMessage>;
+    batch(config: QueueBatchConsumerConfig<E, TMessage>): QueueBatchConsumerRef<TMessage>;
+}
+interface QueueJobHandle<E, TMessage> {
+    message(config: QueueMessageConsumerConfig<E, TMessage>): QueueJobConsumerRef<TMessage>;
+}
+type MultiJobQueueHandle<E, TJobs extends Record<string, QueueJobConfig<z.ZodTypeAny>>> = {
+    [K in keyof TJobs]: QueueJobHandle<E, z.infer<TJobs[K]['args']>>;
+};
+interface DurableObjectHandle<E, TKey> {
+    fn<TArgsSchema extends z.ZodTypeAny, TReturn>(config: DurableFnConfig<E, TArgsSchema, TReturn>): DurableFnRef<TKey, z.infer<TArgsSchema>, TReturn>;
+    internal<TArgsSchema extends z.ZodTypeAny, TReturn>(config: DurableFnConfig<E, TArgsSchema, TReturn>): DurableFnRef<TKey, z.infer<TArgsSchema>, TReturn>;
+    fetch(config: DurableFetchConfig<E>): DurableFetchRef;
+    alarm(config: DurableAlarmConfig<E>): DurableAlarmRef;
+    init(config: DurableInitConfig<E>): DurableInitRef;
+    websocket<TAttachment = unknown>(config: DurableWebSocketConfig<E, TAttachment>): DurableWebSocketRef<TAttachment>;
+}
+interface QueueConsumerRef<TMessage> {
+    readonly __type?: 'queue-message';
+    readonly __message?: TMessage;
+}
+interface QueueBatchConsumerRef<TMessage> {
+    readonly __type?: 'queue-batch';
+    readonly __message?: TMessage;
+}
+interface QueueJobConsumerRef<TMessage> {
+    readonly __type?: 'queue-job-message';
+    readonly __message?: TMessage;
+}
+interface DurableFnRef<TKey, TArgs, TReturn> {
+    readonly __type?: 'durable-fn';
+    readonly __key?: TKey;
+    readonly __args?: TArgs;
+    readonly __return?: TReturn;
+}
+interface DurableFetchRef {
+    readonly __type?: 'durable-fetch';
+}
+interface DurableAlarmRef {
+    readonly __type?: 'durable-alarm';
+}
+interface DurableInitRef {
+    readonly __type?: 'durable-init';
+}
+interface DurableWebSocketRef<TAttachment> {
+    readonly __type?: 'durable-websocket';
+    readonly __attachment?: TAttachment;
+}
+type QueuePayload<TQueue> = TQueue extends QueueHandle<any, infer TMessage> ? TMessage : never;
+type QueueJobPayload<TJob> = TJob extends QueueJobHandle<any, infer TMessage> ? TMessage : never;
+type DurableObjectKey<TObject> = TObject extends DurableObjectHandle<any, infer TKey> ? TKey : never;
+type DurableFnKey<TFn> = TFn extends DurableFnRef<infer TKey, any, any> ? TKey : never;
+type DurableFnArgs<TFn> = TFn extends DurableFnRef<any, infer TArgs, any> ? TArgs : never;
+type DurableFnReturn<TFn> = TFn extends DurableFnRef<any, any, infer TReturn> ? TReturn : never;
+interface DefineDurableObject<E> {
+    <TKeySchema extends z.ZodTypeAny>(config: DurableObjectConfig<TKeySchema>): DurableObjectHandle<E, z.infer<TKeySchema>>;
+}
+interface DefineQueue<E> {
+    <TSchema extends z.ZodTypeAny>(config: QueueConfig<TSchema>): QueueHandle<E, z.infer<TSchema>>;
+}
+interface DefineQueues<E> {
+    <const TConfig extends Record<string, unknown>>(config: MultiJobQueueConfig<TConfig>): MultiJobQueueHandle<E, ExtractQueueJobs<TConfig>>;
+}
+type ExtractQueueJobs<TConfig extends Record<string, unknown>> = {
+    [K in keyof TConfig as TConfig[K] extends QueueJobConfig<z.ZodTypeAny> ? K : never]: TConfig[K] extends QueueJobConfig<z.ZodTypeAny> ? TConfig[K] : never;
+};
+interface DefineWorker<E> {
+    (config: WorkerConfig<E>): WorkerEntrypoint<E>;
+}
+interface BetterCfSDK<E> {
+    defineDurableObject: DefineDurableObject<E>;
+    defineQueue: DefineQueue<E>;
+    defineQueues: DefineQueues<E>;
+    defineWorker: DefineWorker<E>;
+}
+
+export type { MultiJobQueueHandle as A, BetterCfAutoEnv as B, ConsumerBatchEntry as C, DefineDurableObject as D, QueueBatchConsumerRef as E, QueueBatchContext as F, QueueCommonConfig as G, QueueConfig as H, QueueConsumerRef as I, QueueHandle as J, QueueJobConfig as K, QueueJobConsumerRef as L, MultiJobQueueConfig as M, QueueJobHandle as N, QueueJobPayload as O, PullConsumerConfig as P, QueueBatchConsumerConfig as Q, QueueMessageConsumerConfig as R, QueueMessageContext as S, QueuePayload as T, RuntimeApi as U, RuntimeEnv as V, SendBatchEntry as W, SendOptions as X, WorkerConfig as Y, WorkerContext as Z, WorkerEntrypoint as _, BetterCfSDK as a, BetterCfGeneratedApi as b, BetterCfGeneratedBindings as c, ContentType as d, DefineQueue as e, DefineQueues as f, DefineWorker as g, DurableAlarmConfig as h, DurableBaseContext as i, DurableFetchConfig as j, DurableFetchRef as k, DurableFnArgs as l, DurableFnConfig as m, DurableFnKey as n, DurableFnRef as o, DurableFnReturn as p, DurableInitConfig as q, DurableInitRef as r, DurableObjectConfig as s, DurableObjectHandle as t, DurableObjectKey as u, DurableWebSocketConfig as v, DurableWebSocketConnectContext as w, DurableWebSocketEventContext as x, DurableWebSocketRef as y, Duration as z };

package/package.json

@@ -1,10 +1,18 @@
 {
   "name": "better-cf",
-  "version": "1.0.0",
-  "description": "Type-safe Cloudflare Queue SDK and CLI",
+  "version": "2.0.0",
+  "description": "Functional, type-safe Cloudflare SDK suite for Durable Objects and Queues",
+  "keywords": [
+    "cloudflare",
+    "durable-objects",
+    "queues",
+    "workers",
+    "typescript",
+    "zod"
+  ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/imaxisXD/Better-Cf-Sdk"
+    "url": "git+https://github.com/imaxisXD/Better-Cf-Sdk.git"
   },
   "homepage": "https://github.com/imaxisXD/Better-Cf-Sdk#readme",
   "bugs": {
@@ -26,6 +34,14 @@
       "types": "./dist/queue/internal.d.ts",
       "default": "./dist/queue/internal.js"
     },
+    "./durable-object": {
+      "types": "./dist/durable-object/index.d.ts",
+      "default": "./dist/durable-object/index.js"
+    },
+    "./durable-object/internal": {
+      "types": "./dist/durable-object/internal.d.ts",
+      "default": "./dist/durable-object/internal.js"
+    },
     "./testing": {
       "types": "./dist/testing/index.d.ts",
       "default": "./dist/testing/index.js"
@@ -60,12 +76,16 @@
     "release:publish": "npm run build && npm publish --access public --tag ${NPM_TAG:-latest}"
   },
   "dependencies": {
+    "@clack/prompts": "^0.10.1",
     "@iarna/toml": "^2.2.5",
     "chokidar": "^3.6.0",
     "commander": "^12.1.0",
     "jsonc-parser": "^3.3.1",
+    "magic-string": "^0.30.17",
+    "oxc-parser": "^0.81.0",
+    "package-manager-detector": "^0.2.11",
     "picocolors": "^1.1.1",
-    "ts-morph": "^27.0.2"
+    "tinyexec": "^0.3.2"
   },
   "peerDependencies": {
     "@cloudflare/workers-types": ">=4.20240117.0",