qarpeo 0.0.0-alpha.10

package/dist/runtime/blob.mjs

@@ -0,0 +1,334 @@
+import { getCloudflareEnv, resolveRuntimeBinding } from "./bindings.mjs";
+function createHttpError(statusCode, statusMessage) {
+  const err = new Error(statusMessage);
+  err.statusCode = statusCode;
+  err.statusMessage = statusMessage;
+  return err;
+}
+function decodePathname(pathname) {
+  try {
+    return decodeURIComponent(pathname);
+  } catch {
+    return pathname;
+  }
+}
+function assertValidPathname(pathname) {
+  if (!pathname || typeof pathname !== "string") {
+    throw createHttpError(400, "Blob pathname must be a non-empty string");
+  }
+  if (/[\x00-\x1f\x7f]/.test(pathname)) {
+    throw createHttpError(400, `Blob pathname contains invalid control characters: "${pathname}"`);
+  }
+  if (pathname.startsWith("/") || pathname.endsWith("/")) {
+    throw createHttpError(400, `Blob pathname must not start or end with "/": "${pathname}"`);
+  }
+  const segments = pathname.split("/");
+  for (const segment of segments) {
+    if (segment === "." || segment === "..") {
+      throw createHttpError(
+        400,
+        `Blob pathname contains invalid path segment "${segment}": "${pathname}"`
+      );
+    }
+  }
+}
+export function getR2Binding(bindingName, event) {
+  const resolvedBinding = resolveRuntimeBinding("blob", bindingName, "BLOB");
+  const env = getCloudflareEnv(event);
+  const binding = env[resolvedBinding];
+  if (!binding) {
+    throw new Error(
+      `[qarpeo] Cloudflare R2 binding "${resolvedBinding}" was not found. Check your wrangler.json or QARPEO_BLOB_BINDING environment variable.`
+    );
+  }
+  return binding;
+}
+export function parseByteSize(size) {
+  if (typeof size === "number") return size;
+  const match = size.trim().match(/^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb)?$/i);
+  if (!match) return Number(size) || 0;
+  const num = parseFloat(match[1]);
+  const unit = match[2]?.toLowerCase() || "b";
+  const multipliers = {
+    b: 1,
+    kb: 1024,
+    mb: 1024 * 1024,
+    gb: 1024 * 1024 * 1024
+  };
+  return Math.round(num * (multipliers[unit] || 1));
+}
+function matchesMimeType(actual, pattern) {
+  if (pattern === "*/*" || pattern === "*") return true;
+  if (pattern.endsWith("/*")) {
+    const base = pattern.split("/")[0];
+    return actual.startsWith(`${base}/`);
+  }
+  return actual.toLowerCase() === pattern.toLowerCase();
+}
+export function ensureBlob(file, options) {
+  if (options.maxSize !== void 0 && file.size !== void 0) {
+    const maxBytes = parseByteSize(options.maxSize);
+    if (file.size > maxBytes) {
+      throw createHttpError(413, `File exceeds maximum allowed size of ${options.maxSize}`);
+    }
+  }
+  if (options.types && file.type) {
+    const allowed = Array.isArray(options.types) ? options.types : [options.types];
+    const isAllowed = allowed.some((pat) => matchesMimeType(file.type, pat));
+    if (!isAllowed) {
+      throw createHttpError(
+        415,
+        `Unsupported file type "${file.type}". Allowed: ${allowed.join(", ")}`
+      );
+    }
+  }
+}
+async function getEventFormData(event) {
+  const req = event.req || event.node?.req || event;
+  if (typeof req?.formData === "function") {
+    return await req.formData();
+  }
+  if (typeof event.formData === "function") {
+    return await event.formData();
+  }
+  throw createHttpError(400, "Current request does not contain valid multipart/form-data");
+}
+function inferContentType(pathname) {
+  const ext = pathname.split(".").pop()?.toLowerCase();
+  const map = {
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    webp: "image/webp",
+    svg: "image/svg+xml",
+    ico: "image/x-icon",
+    avif: "image/avif",
+    pdf: "application/pdf",
+    txt: "text/plain",
+    html: "text/html",
+    css: "text/css",
+    js: "text/javascript",
+    mjs: "text/javascript",
+    json: "application/json",
+    xml: "application/xml",
+    csv: "text/csv",
+    md: "text/markdown",
+    mp4: "video/mp4",
+    webm: "video/webm",
+    mp3: "audio/mpeg",
+    ogg: "audio/ogg",
+    wav: "audio/wav",
+    zip: "application/zip",
+    gz: "application/gzip",
+    tar: "application/x-tar",
+    woff: "font/woff",
+    woff2: "font/woff2",
+    ttf: "font/ttf",
+    otf: "font/otf"
+  };
+  return ext ? map[ext] : void 0;
+}
+export function createBlob(bindingName, event) {
+  const resolvedBinding = resolveRuntimeBinding("blob", bindingName, "BLOB");
+  const getR2 = () => getR2Binding(resolvedBinding, event);
+  return {
+    put: async (pathname, data, options) => {
+      const r2 = getR2();
+      const decoded = decodePathname(pathname);
+      assertValidPathname(decoded);
+      const contentType = options?.contentType || inferContentType(decoded);
+      return await r2.put(decoded, data, {
+        httpMetadata: {
+          ...options?.httpMetadata,
+          ...contentType ? { contentType } : {}
+        },
+        customMetadata: options?.customMetadata
+      });
+    },
+    get: async (pathname) => {
+      const r2 = getR2();
+      const decoded = decodePathname(pathname);
+      assertValidPathname(decoded);
+      return await r2.get(decoded);
+    },
+    text: async (pathname) => {
+      const r2 = getR2();
+      const decoded = decodePathname(pathname);
+      assertValidPathname(decoded);
+      const obj = await r2.get(decoded);
+      return obj ? await obj.text() : null;
+    },
+    json: async (pathname) => {
+      const r2 = getR2();
+      const decoded = decodePathname(pathname);
+      assertValidPathname(decoded);
+      const obj = await r2.get(decoded);
+      return obj ? await obj.json() : null;
+    },
+    arrayBuffer: async (pathname) => {
+      const r2 = getR2();
+      const decoded = decodePathname(pathname);
+      assertValidPathname(decoded);
+      const obj = await r2.get(decoded);
+      return obj ? await obj.arrayBuffer() : null;
+    },
+    has: async (pathname) => {
+      const r2 = getR2();
+      const decoded = decodePathname(pathname);
+      assertValidPathname(decoded);
+      const head = await r2.head(decoded);
+      return head !== null;
+    },
+    head: async (pathname) => {
+      const r2 = getR2();
+      const decoded = decodePathname(pathname);
+      assertValidPathname(decoded);
+      return await r2.head(decoded);
+    },
+    delete: async (pathname) => {
+      const r2 = getR2();
+      if (Array.isArray(pathname)) {
+        const decoded = pathname.map((p) => {
+          const d = decodePathname(p);
+          assertValidPathname(d);
+          return d;
+        });
+        await r2.delete(decoded);
+      } else {
+        const decoded = decodePathname(pathname);
+        assertValidPathname(decoded);
+        await r2.delete(decoded);
+      }
+    },
+    list: async (options) => {
+      const r2 = getR2();
+      return await r2.list(options);
+    },
+    serve: async (event2, pathname, options) => {
+      const r2 = getR2();
+      const req = event2.req;
+      const decoded = decodePathname(pathname);
+      assertValidPathname(decoded);
+      const rangeHeader = req?.headers?.get("range");
+      let r2Range = void 0;
+      let isRange = false;
+      if (rangeHeader && rangeHeader.startsWith("bytes=")) {
+        const rangeVal = rangeHeader.slice(6).trim();
+        const [startStr, endStr] = rangeVal.split("-");
+        const start = startStr ? parseInt(startStr, 10) : void 0;
+        const end = endStr ? parseInt(endStr, 10) : void 0;
+        if (start !== void 0 && end !== void 0 && !isNaN(start) && !isNaN(end) && end >= start) {
+          r2Range = { offset: start, length: end - start + 1 };
+          isRange = true;
+        } else if (start !== void 0 && !isNaN(start)) {
+          r2Range = { offset: start };
+          isRange = true;
+        } else if (end !== void 0 && !isNaN(end)) {
+          r2Range = { suffix: end };
+          isRange = true;
+        }
+      }
+      const object = await r2.get(decoded, r2Range ? { range: r2Range } : void 0);
+      if (!object) {
+        return new Response("Not Found", { status: 404 });
+      }
+      const etag = object.httpEtag || object.etag || "";
+      const ifNoneMatch = req?.headers?.get("if-none-match")?.replace(/^W\//, "").replace(/"/g, "");
+      const cleanEtag = etag.replace(/^W\//, "").replace(/"/g, "");
+      const headers = new Headers();
+      object.writeHttpMetadata?.(headers);
+      headers.set("accept-ranges", "bytes");
+      if (etag) {
+        headers.set("etag", etag.startsWith('"') ? etag : `"${etag}"`);
+      }
+      if (options?.cacheControl) {
+        headers.set("cache-control", options.cacheControl);
+      } else if (!headers.has("cache-control")) {
+        headers.set("cache-control", "public, max-age=31536000, immutable");
+      }
+      if (options?.contentDisposition) {
+        headers.set("content-disposition", options.contentDisposition);
+      }
+      if (ifNoneMatch && cleanEtag && (ifNoneMatch === cleanEtag || ifNoneMatch === "*")) {
+        return new Response(null, { status: 304, headers });
+      }
+      if (isRange && !object.range) {
+        return new Response(null, {
+          status: 416,
+          headers: {
+            "content-range": `bytes */${object.size}`,
+            "accept-ranges": "bytes"
+          }
+        });
+      }
+      if (isRange && object.range) {
+        const offset = object.range.offset ?? 0;
+        const length = object.range.length ?? object.size;
+        const end = offset + length - 1;
+        headers.set("content-range", `bytes ${offset}-${end}/${object.size}`);
+        headers.set("content-length", String(length));
+        return new Response(object.body, { status: 206, headers });
+      }
+      return new Response(object.body, { headers });
+    },
+    handleUpload: async (event2, options) => {
+      const formData = await getEventFormData(event2);
+      let targetFile = null;
+      if (options?.formKey) {
+        const val = formData.get(options.formKey);
+        if (val && typeof val.arrayBuffer === "function") {
+          targetFile = val;
+        }
+      } else {
+        for (const [, val] of formData.entries()) {
+          if (val && typeof val.arrayBuffer === "function") {
+            targetFile = val;
+            break;
+          }
+        }
+      }
+      if (!targetFile) {
+        throw createHttpError(400, "No file was found in the upload request");
+      }
+      if (options?.ensure) {
+        ensureBlob(targetFile, options.ensure);
+      }
+      let pathname;
+      if (typeof options?.pathname === "function") {
+        pathname = options.pathname(targetFile);
+      } else if (typeof options?.pathname === "string") {
+        pathname = options.pathname;
+      } else {
+        const safeName = targetFile.name?.replace(/[^a-zA-Z0-9._-]/g, "_") || "file";
+        const prefix = options?.prefix || "";
+        pathname = `${prefix}${Date.now()}-${safeName}`;
+      }
+      const r2Object = await createBlob(bindingName, event2).put(pathname, targetFile, {
+        contentType: targetFile.type || void 0,
+        customMetadata: options?.customMetadata
+      });
+      return {
+        ...r2Object,
+        pathname
+      };
+    },
+    createMultipartUpload: async (pathname, options) => {
+      const r2 = getR2();
+      const decoded = decodePathname(pathname);
+      assertValidPathname(decoded);
+      return await r2.createMultipartUpload(decoded, options);
+    },
+    resumeMultipartUpload: (pathname, uploadId) => {
+      const r2 = getR2();
+      const decoded = decodePathname(pathname);
+      assertValidPathname(decoded);
+      return r2.resumeMultipartUpload(decoded, uploadId);
+    },
+    raw: (bName) => {
+      return getR2Binding(bName || resolvedBinding, event);
+    }
+  };
+}
+export const useBlob = createBlob;
+export const blob = createBlob();

package/dist/runtime/bots.d.ts

@@ -0,0 +1 @@
+export * from "./server/utils/bots";

package/dist/runtime/bots.mjs

@@ -0,0 +1 @@
+export * from "./server/utils/bots.mjs";

package/dist/runtime/browser.d.ts

@@ -0,0 +1,21 @@
+import type { QarpeoBrowser, BrowserBinding } from "./types/browser";
+import type { CFEvent } from "./types/index";
+export type * from "./types/browser";
+/**
+ * Returns the raw Cloudflare Browser Rendering binding from the active environment.
+ *
+ * @param bindingName Optional Cloudflare Browser binding name (defaults to 'BROWSER')
+ * @param event Optional event context
+ */
+export declare function getBrowserBinding(bindingName?: string, event?: CFEvent): BrowserBinding;
+/** Creates a typed Browser Rendering client for a specific binding and optional event. */
+export declare function createBrowser(bindingName?: string, event?: CFEvent): QarpeoBrowser;
+/**
+ * Access a typed Cloudflare Browser Rendering client.
+ *
+ * @param bindingName Optional Browser binding name (defaults to 'BROWSER')
+ * @param event Optional event context
+ */
+export declare const useBrowser: (bindingName?: string, event?: CFEvent) => QarpeoBrowser;
+/** Auto-imported `browser` instance for Cloudflare Browser Rendering operations. */
+export declare const browser: QarpeoBrowser;

package/dist/runtime/browser.mjs

@@ -0,0 +1,64 @@
+import { getCloudflareEnv, resolveRuntimeBinding } from "./bindings.mjs";
+export function getBrowserBinding(bindingName, event) {
+  const resolvedBinding = resolveRuntimeBinding("browser", bindingName, "BROWSER");
+  const env = getCloudflareEnv(event);
+  const binding = env[resolvedBinding];
+  if (!binding) {
+    throw new Error(
+      `[qarpeo] Cloudflare Browser Rendering binding "${resolvedBinding}" was not found. Check your wrangler.json or QARPEO_BROWSER_BINDING environment variable.`
+    );
+  }
+  return binding;
+}
+async function loadPuppeteer() {
+  try {
+    const puppeteer = await import("@cloudflare/puppeteer");
+    return puppeteer.default || puppeteer;
+  } catch {
+    return null;
+  }
+}
+export function createBrowser(bindingName, event) {
+  const resolvedBinding = resolveRuntimeBinding("browser", bindingName, "BROWSER");
+  const getB = () => getBrowserBinding(resolvedBinding, event);
+  return {
+    get binding() {
+      return getB();
+    },
+    async launch(options) {
+      const client = await loadPuppeteer();
+      if (!client) {
+        throw new Error(
+          `[qarpeo] '@cloudflare/puppeteer' is required to launch browser sessions. Please install it with 'vp add -D @cloudflare/puppeteer' or 'npm install -D @cloudflare/puppeteer'.`
+        );
+      }
+      return client.launch(getB(), options);
+    },
+    async connect(sessionId) {
+      const client = await loadPuppeteer();
+      if (!client) {
+        throw new Error(
+          `[qarpeo] '@cloudflare/puppeteer' is required to connect to browser sessions. Please install it with 'vp add -D @cloudflare/puppeteer' or 'npm install -D @cloudflare/puppeteer'.`
+        );
+      }
+      return client.connect(getB(), sessionId);
+    },
+    raw: (bName) => {
+      return getBrowserBinding(bName || resolvedBinding, event);
+    }
+  };
+}
+export const useBrowser = createBrowser;
+export const browser = new Proxy({}, {
+  get(_target, prop) {
+    if (prop === "raw") {
+      return (bindingName) => getBrowserBinding(bindingName);
+    }
+    const instance = createBrowser();
+    const val = instance[prop];
+    if (typeof val === "function") {
+      return val.bind(instance);
+    }
+    return val;
+  }
+});

package/dist/runtime/cache.d.ts

@@ -0,0 +1,19 @@
+export interface EdgeCacheInterface {
+    /** The raw Cloudflare Cache instance (`caches.default`). */
+    raw: any;
+    /** Matches a cached Response for a Request or URL string. */
+    match: (request: Request | string) => Promise<Response | undefined>;
+    /** Puts a Response into the edge cache keyed by Request or URL string. */
+    put: (request: Request | string, response: Response) => Promise<void>;
+    /** Deletes a cached entry by Request or URL string. */
+    delete: (request: Request | string) => Promise<boolean>;
+}
+/**
+ * Access the native Cloudflare Workers Edge Cache (`caches.default`).
+ *
+ * Provides direct access to Cloudflare's Cache API for caching Response objects by Request at the
+ * edge with typed match, put, and delete helpers. Returns `undefined` if running outside a Cloudflare Workers environment.
+ *
+ * @see https://developers.cloudflare.com/workers/runtime-apis/cache/
+ */
+export declare function useEdgeCache(): EdgeCacheInterface | undefined;

package/dist/runtime/cache.mjs

@@ -0,0 +1,12 @@
+export function useEdgeCache() {
+  if (typeof caches !== "undefined" && caches.default) {
+    const raw = caches.default;
+    return {
+      raw,
+      match: (req) => raw.match(typeof req === "string" ? new Request(req) : req),
+      put: (req, res) => raw.put(typeof req === "string" ? new Request(req) : req, res),
+      delete: (req) => raw.delete(typeof req === "string" ? new Request(req) : req)
+    };
+  }
+  return void 0;
+}

package/dist/runtime/cms.d.ts

@@ -0,0 +1,2 @@
+export type * from "./app/composables/cms";
+export type { CMSFieldType, CMSFieldDefinition, CMSBlockDefinition, CMSBlockData, CMSCollectionConfig, CMSRevisionsConfig, CMSOptions, CMSHeadingLink, CMSNavigationItem, CMSEntry, CMSCollection, CMSQueryOptions, CMSCreateInput, CMSUpdateInput, } from "../types";

package/dist/runtime/db.d.ts

@@ -0,0 +1,21 @@
+import type { QarpeoDB, D1Database } from "./types/d1";
+import type { CFEvent } from "./types/index";
+/** Returns the raw Cloudflare D1Database binding from the active environment. */
+export declare function getD1Binding(bindingName?: string, event?: CFEvent): D1Database;
+/** Creates a typed D1 database interface for a specific binding and optional event. */
+export declare function createDB(bindingName?: string, event?: CFEvent): QarpeoDB;
+/**
+ * Access a typed Cloudflare D1 instance.
+ *
+ * @param bindingName Optional Cloudflare D1 binding name (defaults to configured binding or 'DB')
+ * @param event Optional event context
+ */
+export declare const useDB: (bindingName?: string, event?: CFEvent) => QarpeoDB;
+export declare const useD1: (bindingName?: string, event?: CFEvent) => QarpeoDB;
+/** Auto-imported `db` instance for direct Cloudflare D1 operations. */
+export declare const db: QarpeoDB;
+/**
+ * Auto-imported `d1` instance for direct Cloudflare D1 operations. Always points directly to native
+ * D1 SQL operations even when `db` is mapped to an ORM.
+ */
+export declare const d1: QarpeoDB;

package/dist/runtime/db.mjs

@@ -0,0 +1,36 @@
+import { getCloudflareEnv, resolveRuntimeBinding } from "./bindings.mjs";
+export function getD1Binding(bindingName, event) {
+  const resolvedBinding = resolveRuntimeBinding("db", bindingName, "DB");
+  const env = getCloudflareEnv(event);
+  const binding = env[resolvedBinding];
+  if (!binding) {
+    throw new Error(
+      `[qarpeo] Cloudflare D1 binding "${resolvedBinding}" was not found. Check your wrangler.json or QARPEO_DB_BINDING environment variable.`
+    );
+  }
+  return binding;
+}
+export function createDB(bindingName, event) {
+  const getD1 = () => getD1Binding(bindingName, event);
+  return {
+    prepare: (query) => {
+      return getD1().prepare(query);
+    },
+    batch: (statements) => {
+      return getD1().batch(statements);
+    },
+    exec: (query) => {
+      return getD1().exec(query);
+    },
+    dump: () => {
+      return getD1().dump();
+    },
+    raw: (bName) => {
+      return getD1Binding(bName || bindingName, event);
+    }
+  };
+}
+export const useDB = createDB;
+export const useD1 = createDB;
+export const db = createDB();
+export const d1 = createDB();

package/dist/runtime/drizzle.d.ts

@@ -0,0 +1,11 @@
+import type { QarpeoDrizzleDB, InferDrizzleRelations } from "./types/drizzle";
+import type { CFEvent } from "./types/index";
+export type { QarpeoDrizzleDB, InferDrizzleRelations } from "./types/drizzle";
+/**
+ * Creates or accesses a typed Drizzle ORM client connected to Cloudflare D1.
+ *
+ * @param schema The database schema containing tables
+ * @param bindingName Optional Cloudflare D1 binding name (defaults to configured binding or 'DB')
+ * @param event Optional event context
+ */
+export declare function createDrizzle<TSchema extends Record<string, unknown>>(schema: TSchema, bindingName?: string, event?: CFEvent): QarpeoDrizzleDB<InferDrizzleRelations<TSchema>>;

package/dist/runtime/drizzle.mjs

@@ -0,0 +1,18 @@
+import { defineRelations } from "drizzle-orm";
+import { drizzle as drizzleD1 } from "drizzle-orm/d1";
+import { getD1Binding } from "./db.mjs";
+const drizzleCache = /* @__PURE__ */ new WeakMap();
+export function createDrizzle(schema, bindingName, event) {
+  const resolvedBinding = bindingName || globalThis.process?.env?.QARPEO_DEFAULT_DB_BINDING || globalThis.process?.env?.DB_BINDING || "DB";
+  const d1 = getD1Binding(resolvedBinding, event);
+  let instance = drizzleCache.get(d1);
+  if (!instance) {
+    const relations = defineRelations(schema);
+    const rawDrizzle = drizzleD1(d1, { relations });
+    instance = Object.assign(rawDrizzle, {
+      raw: (bName) => getD1Binding(bName || resolvedBinding, event)
+    });
+    drizzleCache.set(d1, instance);
+  }
+  return instance;
+}

package/dist/runtime/email.d.ts

@@ -0,0 +1,51 @@
+import type { EmailSenderIdentity, QarpeoEmail, SendEmailBinding, SendEmailOptions, SendEmailResult } from "./types/email";
+import type { CFEvent } from "./types/index";
+export type { EmailSenderIdentity, QarpeoEmail, SendEmailBinding, SendEmailOptions, SendEmailResult, } from "./types/email";
+/**
+ * Parses an email address label like "Support Team [support@myapp.com](mailto:support@myapp.com)"
+ * into an EmailSenderIdentity.
+ */
+export declare function parseSenderIdentity(key: string, raw: string): EmailSenderIdentity;
+/**
+ * Universal composable to access configured sender identities / inboxes. Available in Vue
+ * components, pages, composables, and Nitro server handlers.
+ */
+export declare function useEmailSenders(): {
+    senders: EmailSenderIdentity[];
+    defaultSender: EmailSenderIdentity | null;
+    getSender: (keyOrAddress: string) => EmailSenderIdentity | undefined;
+};
+/**
+ * Accesses the raw Cloudflare `send_email` Workers binding from the active environment.
+ *
+ * @param bindingName Optional Cloudflare binding name (defaults to "EMAIL")
+ * @param event Optional event context
+ */
+export declare function getEmailBinding(bindingName?: string, event?: CFEvent): SendEmailBinding;
+/** Builds an RFC 2822 compliant MIME message string. */
+export declare function buildMimeMessage(options: {
+    from: string;
+    to: string | string[];
+    subject: string;
+    text?: string;
+    html?: string;
+    cc?: string | string[];
+    bcc?: string | string[];
+    replyTo?: string;
+    headers?: Record<string, string>;
+    messageId?: string;
+}): string;
+/**
+ * Sends a transactional email using Cloudflare's native `send_email` Workers binding in production,
+ * or intercepts and displays the email in the terminal console during local development.
+ *
+ * @param options Email details (to, from, subject, text, html, etc.)
+ * @param event Optional event context
+ */
+export declare function sendEmail(options: SendEmailOptions, event?: CFEvent): Promise<SendEmailResult>;
+/** Creates a typed email client connected to Cloudflare `send_email`. */
+export declare function createEmail(bindingName?: string, event?: CFEvent): QarpeoEmail;
+/** Access a typed Cloudflare email client. */
+export declare const useEmail: (bindingName?: string, event?: CFEvent) => QarpeoEmail;
+/** Auto-imported `email` instance for sending transactional emails. */
+export declare const email: QarpeoEmail;