@flightdev/core 0.6.7

package/dist/chunk-72MYOTUB.js

@@ -0,0 +1,667 @@
+// src/actions/middleware.ts
+function createActionContext(options) {
+  const store = /* @__PURE__ */ new Map();
+  return {
+    request: options.request,
+    headers: options.headers ?? options.request?.headers ?? new Headers(),
+    actionId: options.actionId,
+    args: options.args,
+    signal: options.signal,
+    get(key) {
+      return store.get(key);
+    },
+    set(key, value) {
+      store.set(key, value);
+    }
+  };
+}
+var middlewareCounter = 0;
+function createActionMiddleware(handler, options = {}) {
+  const name = options.name ?? `middleware_${++middlewareCounter}`;
+  return {
+    name,
+    handler
+  };
+}
+function pipeline(...middlewares) {
+  return (action) => {
+    return async (...args) => {
+      const ctx = createActionContext({
+        actionId: action.name || "anonymous",
+        args
+      });
+      let index = -1;
+      const dispatch = async (i) => {
+        if (i <= index) {
+          throw new Error("next() called multiple times");
+        }
+        index = i;
+        if (i < middlewares.length) {
+          const middleware = middlewares[i];
+          return middleware.handler(ctx, () => dispatch(i + 1));
+        } else {
+          return action(...args);
+        }
+      };
+      return dispatch(0);
+    };
+  };
+}
+async function executeWithMiddleware(action, args, middlewares, options = {}) {
+  const ctx = createActionContext({
+    request: options.request,
+    headers: options.headers,
+    actionId: action.name || "anonymous",
+    args,
+    signal: options.signal
+  });
+  let index = -1;
+  const dispatch = async (i) => {
+    if (options.signal?.aborted) {
+      return { success: false, error: "Aborted", code: "ABORTED" };
+    }
+    if (i <= index) {
+      throw new Error("next() called multiple times");
+    }
+    index = i;
+    if (i < middlewares.length) {
+      const middleware = middlewares[i];
+      return middleware.handler(ctx, () => dispatch(i + 1));
+    } else {
+      return action(...args);
+    }
+  };
+  return dispatch(0);
+}
+function createTimingMiddleware(reporter) {
+  return createActionMiddleware(
+    async (ctx, next) => {
+      const start = performance.now();
+      const result = await next();
+      const duration = performance.now() - start;
+      reporter(ctx.actionId, duration, result);
+      return result;
+    },
+    { name: "timing" }
+  );
+}
+function createLoggingMiddleware(options) {
+  return createActionMiddleware(
+    async (ctx, next) => {
+      options.onStart?.(ctx);
+      const start = performance.now();
+      try {
+        const result = await next();
+        const duration = performance.now() - start;
+        options.onComplete?.(ctx, result, duration);
+        return result;
+      } catch (error) {
+        options.onError?.(ctx, error);
+        throw error;
+      }
+    },
+    { name: "logging" }
+  );
+}
+function createRetryMiddleware(options) {
+  const {
+    maxAttempts,
+    delay = () => 0,
+    shouldRetry = (result) => !result.success
+  } = options;
+  return createActionMiddleware(
+    async (ctx, next) => {
+      let lastResult = { success: false, error: "No attempts made" };
+      for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        if (attempt > 0) {
+          const delayMs = delay(attempt);
+          if (delayMs > 0) {
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+          }
+        }
+        lastResult = await next();
+        if (!shouldRetry(lastResult)) {
+          return lastResult;
+        }
+      }
+      return lastResult;
+    },
+    { name: "retry" }
+  );
+}
+
+// src/actions/streaming.ts
+function createStreamableAction(generator, options = {}) {
+  options.name ?? generator.name ?? "streamable_action";
+  return (input) => {
+    const abortController = new AbortController();
+    let completed = false;
+    let finalResult = null;
+    let resolveDone;
+    const done = new Promise((resolve) => {
+      resolveDone = resolve;
+    });
+    let timeoutId;
+    if (options.timeout) {
+      timeoutId = setTimeout(() => {
+        abortController.abort();
+      }, options.timeout);
+    }
+    async function* iterate() {
+      try {
+        const gen = generator(input, abortController.signal);
+        while (true) {
+          if (abortController.signal.aborted) {
+            const abortResult = {
+              type: "result",
+              success: false,
+              error: "Stream aborted"
+            };
+            finalResult = abortResult;
+            resolveDone(abortResult);
+            yield abortResult;
+            return;
+          }
+          const next = await gen.next();
+          if (next.done) {
+            const successResult = {
+              type: "result",
+              success: true,
+              data: next.value
+            };
+            finalResult = successResult;
+            completed = true;
+            resolveDone(successResult);
+            yield successResult;
+            return;
+          } else {
+            yield {
+              type: "progress",
+              data: next.value
+            };
+          }
+        }
+      } catch (error) {
+        const errorResult = {
+          type: "result",
+          success: false,
+          error: error instanceof Error ? error.message : "Unknown error"
+        };
+        finalResult = errorResult;
+        resolveDone(errorResult);
+        yield errorResult;
+      } finally {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+      }
+    }
+    const iterator = iterate();
+    return {
+      [Symbol.asyncIterator]() {
+        return iterator;
+      },
+      abort() {
+        abortController.abort();
+      },
+      done
+    };
+  };
+}
+function streamToResponse(controller, options = {}) {
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    async start(streamController) {
+      try {
+        for await (const item of controller) {
+          const chunk = JSON.stringify(item) + "\n";
+          streamController.enqueue(encoder.encode(chunk));
+          if (item.type === "result") {
+            break;
+          }
+        }
+      } catch (error) {
+        const errorChunk = JSON.stringify({
+          type: "result",
+          success: false,
+          error: error instanceof Error ? error.message : "Stream error"
+        }) + "\n";
+        streamController.enqueue(encoder.encode(errorChunk));
+      } finally {
+        streamController.close();
+      }
+    },
+    cancel() {
+      controller.abort();
+    }
+  });
+  return new Response(stream, {
+    status: 200,
+    headers: {
+      "Content-Type": "application/x-ndjson",
+      "Transfer-Encoding": "chunked",
+      "Cache-Control": "no-cache",
+      "Connection": "keep-alive",
+      ...options.headers
+    }
+  });
+}
+function responseToStream(response) {
+  const reader = response.body?.getReader();
+  const decoder = new TextDecoder();
+  if (!reader) {
+    throw new Error("Response body is not readable");
+  }
+  return (async function* () {
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (line.trim()) {
+            try {
+              const item = JSON.parse(line);
+              yield item;
+            } catch {
+            }
+          }
+        }
+      }
+      if (buffer.trim()) {
+        try {
+          const item = JSON.parse(buffer);
+          yield item;
+        } catch {
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  })();
+}
+async function collectStream(controller) {
+  const items = [];
+  let result = null;
+  for await (const item of controller) {
+    items.push(item);
+    if (item.type === "result") {
+      result = item;
+    }
+  }
+  if (!result) {
+    result = { type: "result", success: false, error: "No result received" };
+  }
+  return { items, result };
+}
+function createProgressReporter(onProgress, onComplete) {
+  return (item) => {
+    if (item.type === "progress") {
+      onProgress(item.data);
+    } else {
+      onComplete?.(item);
+    }
+  };
+}
+
+// src/actions/queue.ts
+var entryCounter = 0;
+function generateEntryId() {
+  return `${Date.now()}_${++entryCounter}_${Math.random().toString(36).substring(2, 9)}`;
+}
+function createQueuedAction(action, options) {
+  const {
+    storage,
+    actionId = action.name || `action_${Date.now()}`,
+    retryStrategy = defaultRetryStrategy,
+    isOnline = defaultIsOnline,
+    onStatusChange,
+    onSuccess,
+    onFailure
+  } = options;
+  let isProcessing = false;
+  let processorRunning = false;
+  startProcessor();
+  async function startProcessor() {
+    if (processorRunning) return;
+    processorRunning = true;
+    while (processorRunning) {
+      await processQueue();
+      await sleep(1e3);
+    }
+  }
+  async function processQueue() {
+    const online = await isOnline();
+    if (!online) {
+      return;
+    }
+    const entry = await storage.dequeue();
+    if (!entry) {
+      if (isProcessing) {
+        isProcessing = false;
+        await notifyStatus();
+      }
+      return;
+    }
+    isProcessing = true;
+    await notifyStatus();
+    await storage.update(entry.id, { status: "processing" });
+    try {
+      const result = await action(entry.input);
+      await storage.remove(entry.id);
+      onSuccess?.(entry, result);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      const { shouldRetry, delayMs } = retryStrategy(entry, err);
+      if (shouldRetry) {
+        await storage.update(entry.id, {
+          status: "pending",
+          attempts: entry.attempts + 1,
+          lastError: err.message
+        });
+        if (delayMs > 0) {
+          await sleep(delayMs);
+        }
+      } else {
+        await storage.update(entry.id, {
+          status: "failed",
+          lastError: err.message
+        });
+        onFailure?.(entry, err);
+      }
+    }
+  }
+  async function notifyStatus() {
+    if (!onStatusChange) return;
+    const entries = await storage.peek();
+    const status = {
+      isProcessing,
+      pendingCount: entries.filter((e) => e.status === "pending").length,
+      failedCount: entries.filter((e) => e.status === "failed").length,
+      isOnline: await isOnline()
+    };
+    onStatusChange(status);
+  }
+  return async (input) => {
+    const online = await isOnline();
+    if (online) {
+      try {
+        const result = await action(input);
+        return { queued: false, result };
+      } catch {
+      }
+    }
+    const entry = {
+      id: generateEntryId(),
+      actionId,
+      input,
+      queuedAt: Date.now(),
+      attempts: 0,
+      status: "pending"
+    };
+    await storage.enqueue(entry);
+    await notifyStatus();
+    return { queued: true, entryId: entry.id };
+  };
+}
+var defaultRetryStrategy = (entry) => ({
+  shouldRetry: entry.attempts < 3,
+  delayMs: 1e3
+});
+function exponentialBackoff(options = {}) {
+  const {
+    maxAttempts = 5,
+    baseDelayMs = 1e3,
+    maxDelayMs = 3e4
+  } = options;
+  return (entry) => {
+    const shouldRetry = entry.attempts < maxAttempts;
+    const delayMs = Math.min(
+      baseDelayMs * Math.pow(2, entry.attempts),
+      maxDelayMs
+    );
+    return { shouldRetry, delayMs };
+  };
+}
+function fixedDelay(options = {}) {
+  const { maxAttempts = 3, delayMs = 1e3 } = options;
+  return (entry) => ({
+    shouldRetry: entry.attempts < maxAttempts,
+    delayMs
+  });
+}
+function createMemoryAdapter() {
+  const store = /* @__PURE__ */ new Map();
+  return {
+    async enqueue(entry) {
+      store.set(entry.id, entry);
+    },
+    async dequeue() {
+      for (const [id, entry] of store.entries()) {
+        if (entry.status === "pending") {
+          store.delete(id);
+          return entry;
+        }
+      }
+      return null;
+    },
+    async peek() {
+      return Array.from(store.values());
+    },
+    async update(id, updates) {
+      const entry = store.get(id);
+      if (entry) {
+        store.set(id, { ...entry, ...updates });
+      }
+    },
+    async remove(id) {
+      store.delete(id);
+    },
+    async clear() {
+      store.clear();
+    },
+    async length() {
+      return store.size;
+    }
+  };
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function defaultIsOnline() {
+  if (typeof navigator !== "undefined" && "onLine" in navigator) {
+    return navigator.onLine;
+  }
+  return true;
+}
+function createQueueManager(options) {
+  let paused = false;
+  return {
+    pause() {
+      paused = true;
+    },
+    resume() {
+      paused = false;
+    },
+    async getStatus() {
+      const entries = await options.storage.peek();
+      return {
+        isProcessing: !paused,
+        pendingCount: entries.filter((e) => e.status === "pending").length,
+        failedCount: entries.filter((e) => e.status === "failed").length,
+        isOnline: defaultIsOnline()
+      };
+    },
+    async clearFailed() {
+      const entries = await options.storage.peek();
+      for (const entry of entries) {
+        if (entry.status === "failed") {
+          await options.storage.remove(entry.id);
+        }
+      }
+    },
+    async retryFailed() {
+      const entries = await options.storage.peek();
+      for (const entry of entries) {
+        if (entry.status === "failed") {
+          await options.storage.update(entry.id, {
+            status: "pending",
+            attempts: 0,
+            lastError: void 0
+          });
+        }
+      }
+    }
+  };
+}
+
+// src/actions/index.ts
+var actionRegistry = /* @__PURE__ */ new Map();
+function registerAction(action) {
+  actionRegistry.set(action.id, action);
+}
+function getAction(id) {
+  return actionRegistry.get(id);
+}
+function getAllActions() {
+  return Array.from(actionRegistry.values());
+}
+function clearActions() {
+  actionRegistry.clear();
+}
+async function executeAction(actionId, args) {
+  const action = getAction(actionId);
+  if (!action) {
+    return {
+      success: false,
+      error: `Action not found: ${actionId}`
+    };
+  }
+  try {
+    const result = await action.fn(...args);
+    return {
+      success: true,
+      data: result
+    };
+  } catch (error) {
+    if (isRedirectError(error)) {
+      throw error;
+    }
+    console.error(`[Flight] Action error (${actionId}):`, error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+async function executeFormAction(actionId, formData) {
+  return executeAction(actionId, [formData]);
+}
+var actionCounter = 0;
+function generateActionId(name, filePath) {
+  const hash = simpleHash(`${filePath}:${name}`);
+  return `action_${hash}_${actionCounter++}`;
+}
+function simpleHash(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash).toString(36);
+}
+function cookies() {
+  const cookieStore = globalThis.__flightCookies;
+  if (!cookieStore) {
+    console.warn("[Flight] Cookies not available outside of action context");
+    return {
+      get: () => void 0,
+      set: () => {
+      },
+      delete: () => {
+      }
+    };
+  }
+  return cookieStore;
+}
+function redirect(url) {
+  throw new RedirectError(url);
+}
+var RedirectError = class extends Error {
+  url;
+  constructor(url) {
+    super(`Redirect to ${url}`);
+    this.name = "RedirectError";
+    this.url = url;
+  }
+};
+function isRedirectError(error) {
+  return error instanceof RedirectError;
+}
+function parseFormData(formData) {
+  const result = {};
+  formData.forEach((value, key) => {
+    result[key] = String(value);
+  });
+  return result;
+}
+function createActionReference(actionId) {
+  return `/__flight_action/${actionId}`;
+}
+async function handleActionRequest(request) {
+  const url = new URL(request.url);
+  const actionPath = url.pathname;
+  const match = actionPath.match(/^\/__flight_action\/(.+)$/);
+  if (!match) {
+    return new Response(JSON.stringify({ error: "Invalid action path" }), {
+      status: 400,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  const actionId = match[1];
+  if (!actionId) {
+    return new Response(JSON.stringify({ error: "Missing action ID" }), {
+      status: 400,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  try {
+    let result;
+    const contentType = request.headers.get("content-type") || "";
+    if (contentType.includes("application/x-www-form-urlencoded") || contentType.includes("multipart/form-data")) {
+      const formData = await request.formData();
+      result = await executeFormAction(actionId, formData);
+    } else {
+      const args = await request.json();
+      result = await executeAction(actionId, Array.isArray(args) ? args : [args]);
+    }
+    return new Response(JSON.stringify(result), {
+      status: result.success ? 200 : 400,
+      headers: { "Content-Type": "application/json" }
+    });
+  } catch (error) {
+    if (isRedirectError(error)) {
+      return new Response(null, {
+        status: 303,
+        headers: { Location: error.url }
+      });
+    }
+    return new Response(JSON.stringify({
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error"
+    }), {
+      status: 500,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+}
+
+export { RedirectError, clearActions, collectStream, cookies, createActionContext, createActionMiddleware, createActionReference, createLoggingMiddleware, createMemoryAdapter, createProgressReporter, createQueueManager, createQueuedAction, createRetryMiddleware, createStreamableAction, createTimingMiddleware, defaultRetryStrategy, executeAction, executeFormAction, executeWithMiddleware, exponentialBackoff, fixedDelay, generateActionId, getAction, getAllActions, handleActionRequest, isRedirectError, parseFormData, pipeline, redirect, registerAction, responseToStream, streamToResponse };
+//# sourceMappingURL=chunk-72MYOTUB.js.map
+//# sourceMappingURL=chunk-72MYOTUB.js.map