qarpeo 0.0.0-alpha.10

package/dist/runtime/server/utils/domains.mjs

@@ -0,0 +1,318 @@
+import { getKVBinding } from "../../kv.mjs";
+const devDomainsStore = /* @__PURE__ */ new Map();
+const devCache = /* @__PURE__ */ new Map();
+export function normalizeDomain(input) {
+  let domain = input.trim().toLowerCase();
+  try {
+    if (domain.includes("://")) {
+      domain = new URL(domain).hostname;
+    }
+  } catch {
+  }
+  return domain.replace(/\/.*$/, "").replace(/\.$/, "");
+}
+export function isValidDomain(domain) {
+  if (!domain || domain.length > 253) return false;
+  const domainRegex = /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?(\.[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)+$/i;
+  return domainRegex.test(domain);
+}
+export function getMultitenantConfig(event) {
+  try {
+    const rc = event?.context?.nitro?.runtimeConfig ?? event?.$config;
+    return rc?.qarpeo?.multitenant || {};
+  } catch {
+    return {};
+  }
+}
+export async function getDomainCache(domain, event) {
+  const norm = normalizeDomain(domain);
+  const now = Date.now();
+  const mem = devCache.get(norm);
+  if (mem && mem.expiresAt > now) {
+    return mem.tenantId;
+  }
+  try {
+    const config = getMultitenantConfig(event);
+    const bindingName = config.kvBinding || "KV";
+    const kv = getKVBinding(bindingName, event);
+    const val = await kv.get(`domain:${norm}`);
+    if (val) {
+      devCache.set(norm, { tenantId: val, expiresAt: now + 6e4 });
+      return val;
+    }
+  } catch {
+  }
+  const record = devDomainsStore.get(norm);
+  if (record && record.status === "active") {
+    return record.tenantId;
+  }
+  return null;
+}
+export async function setDomainCache(domain, tenantId, event, ttlSeconds = 86400) {
+  const norm = normalizeDomain(domain);
+  devCache.set(norm, { tenantId, expiresAt: Date.now() + ttlSeconds * 1e3 });
+  try {
+    const config = getMultitenantConfig(event);
+    const bindingName = config.kvBinding || "KV";
+    const kv = getKVBinding(bindingName, event);
+    await kv.put(`domain:${norm}`, tenantId, { expirationTtl: ttlSeconds });
+  } catch {
+  }
+}
+export async function removeDomainCache(domain, event) {
+  const norm = normalizeDomain(domain);
+  devCache.delete(norm);
+  try {
+    const config = getMultitenantConfig(event);
+    const bindingName = config.kvBinding || "KV";
+    const kv = getKVBinding(bindingName, event);
+    await kv.delete(`domain:${norm}`);
+  } catch {
+  }
+}
+async function callCloudflareHostnamesApi(endpoint, method, body, config) {
+  const zoneId = config?.zoneId || process.env.CLOUDFLARE_ZONE_ID || process.env.CF_ZONE_ID;
+  const apiToken = config?.apiToken || process.env.CLOUDFLARE_API_TOKEN || process.env.CF_API_TOKEN;
+  if (!zoneId || !apiToken) {
+    return null;
+  }
+  const url = `https://api.cloudflare.com/client/v4/zones/${zoneId}/custom_hostnames${endpoint}`;
+  const headers = {
+    Authorization: `Bearer ${apiToken}`,
+    "Content-Type": "application/json"
+  };
+  const res = await fetch(url, {
+    method,
+    headers,
+    body: body ? JSON.stringify(body) : void 0
+  });
+  const json = await res.json().catch(() => ({}));
+  if (!res.ok || json.success === false) {
+    const err = json.errors?.[0]?.message || `Cloudflare API error ${res.status}`;
+    throw new Error(`[qarpeo/domains] ${err}`);
+  }
+  return json.result;
+}
+export async function registerCustomDomain(tenantId, rawDomain, options = {}, event) {
+  const domain = normalizeDomain(rawDomain);
+  if (!isValidDomain(domain)) {
+    throw new Error(`[qarpeo/domains] Invalid domain name "${rawDomain}".`);
+  }
+  const config = getMultitenantConfig(event);
+  const cnameTarget = options.cnameTarget || config.cnameTarget || "cname.qarpeo.com";
+  const existing = await getCustomDomain(domain, event);
+  if (existing) {
+    throw new Error(`[qarpeo/domains] Domain "${domain}" is already registered.`);
+  }
+  let cfResult = null;
+  try {
+    cfResult = await callCloudflareHostnamesApi(
+      "",
+      "POST",
+      {
+        hostname: domain,
+        ssl: {
+          method: "http",
+          type: "dv",
+          settings: { min_tls_version: "1.2" }
+        }
+      },
+      config
+    );
+  } catch (err) {
+    if (process.env.NODE_ENV === "production") throw err;
+  }
+  const verificationRecords = [];
+  verificationRecords.push({
+    type: "cname",
+    name: domain,
+    value: cnameTarget,
+    target: cnameTarget
+  });
+  if (cfResult?.ownership_verification) {
+    verificationRecords.push({
+      type: "txt",
+      name: cfResult.ownership_verification.name,
+      value: cfResult.ownership_verification.value
+    });
+  } else if (!cfResult) {
+    verificationRecords.push({
+      type: "txt",
+      name: `_cf-custom-hostname.${domain}`,
+      value: `qarpeo-verify-${Math.random().toString(36).slice(2, 10)}`
+    });
+  }
+  const now = Date.now();
+  const record = {
+    id: cfResult?.id || `dom_${now}_${Math.random().toString(36).slice(2, 8)}`,
+    tenantId,
+    domain,
+    status: cfResult?.status || "pending",
+    sslStatus: cfResult?.ssl?.status || "initializing",
+    verificationRecords,
+    cnameTarget,
+    cloudflareHostnameId: cfResult?.id,
+    createdAt: now,
+    updatedAt: now
+  };
+  devDomainsStore.set(domain, record);
+  try {
+    const db = event?.context?.db;
+    if (db) {
+      await db.run(
+        `INSERT OR REPLACE INTO _qarpeo_domains
+         (id, tenant_id, domain, status, ssl_status, verification_type, verification_target, cloudflare_hostname_id, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        [
+          record.id,
+          record.tenantId,
+          record.domain,
+          record.status,
+          record.sslStatus,
+          "cname",
+          cnameTarget,
+          record.cloudflareHostnameId || null,
+          now,
+          now
+        ]
+      );
+    }
+  } catch {
+  }
+  return record;
+}
+export async function verifyCustomDomain(rawDomain, event) {
+  const domain = normalizeDomain(rawDomain);
+  const record = await getCustomDomain(domain, event);
+  if (!record) {
+    throw new Error(`[qarpeo/domains] Domain "${domain}" not found.`);
+  }
+  const config = getMultitenantConfig(event);
+  let cfResult = null;
+  if (record.cloudflareHostnameId) {
+    try {
+      cfResult = await callCloudflareHostnamesApi(
+        `/${record.cloudflareHostnameId}`,
+        "GET",
+        void 0,
+        config
+      );
+    } catch {
+    }
+  }
+  const now = Date.now();
+  if (cfResult) {
+    record.status = cfResult.status || record.status;
+    record.sslStatus = cfResult.ssl?.status || record.sslStatus;
+    record.errorMessage = cfResult.verification_errors?.[0];
+  } else {
+    record.status = "active";
+    record.sslStatus = "active";
+  }
+  record.updatedAt = now;
+  if (record.status === "active") {
+    await setDomainCache(domain, record.tenantId, event);
+  }
+  devDomainsStore.set(domain, record);
+  try {
+    const db = event?.context?.db;
+    if (db) {
+      await db.run(
+        `UPDATE _qarpeo_domains SET status = ?, ssl_status = ?, updated_at = ? WHERE domain = ?`,
+        [record.status, record.sslStatus, now, domain]
+      );
+    }
+  } catch {
+  }
+  return record;
+}
+export async function getCustomDomain(rawDomain, event) {
+  const domain = normalizeDomain(rawDomain);
+  if (devDomainsStore.has(domain)) {
+    return devDomainsStore.get(domain);
+  }
+  try {
+    const db = event?.context?.db;
+    if (db) {
+      const rows = await db.all(`SELECT * FROM _qarpeo_domains WHERE domain = ? LIMIT 1`, [domain]);
+      if (rows?.[0]) {
+        const row = rows[0];
+        const rec = {
+          id: row.id,
+          tenantId: row.tenant_id,
+          domain: row.domain,
+          status: row.status,
+          sslStatus: row.ssl_status,
+          cnameTarget: row.verification_target,
+          cloudflareHostnameId: row.cloudflare_hostname_id,
+          createdAt: row.created_at,
+          updatedAt: row.updated_at
+        };
+        devDomainsStore.set(domain, rec);
+        return rec;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+export async function listTenantDomains(tenantId, event) {
+  const results = [];
+  for (const rec of devDomainsStore.values()) {
+    if (rec.tenantId === tenantId) {
+      results.push(rec);
+    }
+  }
+  try {
+    const db = event?.context?.db;
+    if (db) {
+      const rows = await db.all(
+        `SELECT * FROM _qarpeo_domains WHERE tenant_id = ? ORDER BY created_at DESC`,
+        [tenantId]
+      );
+      for (const row of rows || []) {
+        if (!results.some((r) => r.domain === row.domain)) {
+          results.push({
+            id: row.id,
+            tenantId: row.tenant_id,
+            domain: row.domain,
+            status: row.status,
+            sslStatus: row.ssl_status,
+            cnameTarget: row.verification_target,
+            cloudflareHostnameId: row.cloudflare_hostname_id,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at
+          });
+        }
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+export async function deleteCustomDomain(rawDomain, event) {
+  const domain = normalizeDomain(rawDomain);
+  const record = await getCustomDomain(domain, event);
+  const config = getMultitenantConfig(event);
+  if (record?.cloudflareHostnameId) {
+    try {
+      await callCloudflareHostnamesApi(
+        `/${record.cloudflareHostnameId}`,
+        "DELETE",
+        void 0,
+        config
+      );
+    } catch {
+    }
+  }
+  devDomainsStore.delete(domain);
+  await removeDomainCache(domain, event);
+  try {
+    const db = event?.context?.db;
+    if (db) {
+      await db.run(`DELETE FROM _qarpeo_domains WHERE domain = ?`, [domain]);
+    }
+  } catch {
+  }
+  return { success: true };
+}

package/dist/runtime/server/utils/drizzle.d.ts

@@ -0,0 +1,10 @@
+import * as _schema from "#qarpeo/schema";
+import type { CFEvent, QarpeoDrizzleDB, InferDrizzleRelations } from "../../index";
+export type { QarpeoDrizzleDB, InferDrizzleRelations } from "../../index";
+type SchemaRelations = InferDrizzleRelations<typeof _schema>;
+/** Access a typed Drizzle ORM client connected to Cloudflare D1. */
+export declare function useDrizzle(bindingName?: string, event?: CFEvent): QarpeoDrizzleDB<SchemaRelations>;
+/** Auto-imported `db` client wrapping Cloudflare D1 with Drizzle ORM. */
+export declare const db: QarpeoDrizzleDB<SchemaRelations>;
+/** All exported tables, views, and relations from your schema (e.g. `server/db/schema.ts`). */
+export declare const schema: typeof _schema;

package/dist/runtime/server/utils/drizzle.mjs

@@ -0,0 +1,36 @@
+import { defineRelations } from "drizzle-orm";
+import { drizzle as drizzleD1 } from "drizzle-orm/d1";
+import * as _schema from "#qarpeo/schema";
+import { getD1Binding } from "../../index.mjs";
+const drizzleCache = /* @__PURE__ */ new WeakMap();
+export function useDrizzle(bindingName, event) {
+  const resolvedBinding = bindingName || globalThis.process?.env?.QARPEO_DEFAULT_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;
+}
+export const db = new Proxy(
+  {},
+  {
+    get(_target, prop) {
+      if (prop === "raw") {
+        return (bindingName) => getD1Binding(bindingName);
+      }
+      const instance = useDrizzle();
+      const val = instance[prop];
+      if (typeof val === "function") {
+        return val.bind(instance);
+      }
+      return val;
+    }
+  }
+);
+export const schema = _schema;

package/dist/runtime/server/utils/email-templates.d.ts

@@ -0,0 +1,44 @@
+import type { EmailTemplateHandler, EmailTemplateName, EmailTemplateResult, MailTemplateOptions } from "../../../types";
+export type { EmailTemplateResult };
+/**
+ * Register a typed custom email template.
+ *
+ * @example
+ *   defineEmailTemplate("invoice-ready", (data: { invoiceId: string; amount: string }, branding) => ({
+ *     subject: `Invoice #${data.invoiceId} is ready`,
+ *     html: `<p>Your invoice for ${data.amount} is ready.</p>`,
+ *     text: `Your invoice for ${data.amount} is ready.`,
+ *   }))
+ */
+export declare function defineEmailTemplate<T = Record<string, any>>(name: string, handler: EmailTemplateHandler<T>): void;
+/** Retrieve a registered custom email template by name. */
+export declare function getEmailTemplate(name: string): EmailTemplateHandler | undefined;
+/** Escapes user-supplied data before inserting into HTML email templates. */
+export declare function escapeHtml(str: unknown): string;
+/** Validates a URL to only allow http/https schemes (prevents javascript: XSS). */
+export declare function sanitizeUrl(url: unknown): string;
+/** Common HTML email layout wrapper with inline styles compatible with Gmail, Apple Mail, Outlook. */
+export declare function renderEmailLayout(options: {
+    title: string;
+    content: string;
+    branding?: MailTemplateOptions;
+}): string;
+/** Renders a primary call-to-action button HTML. */
+export declare function renderEmailButton(url: string, label: string, color?: string): string;
+/**
+ * Lightweight, zero-dependency Markdown-to-Email renderer.
+ * Converts markdown into responsive, inline-styled HTML compatible with major email clients.
+ */
+export declare function renderMarkdownEmail(markdown: string, options?: {
+    title?: string;
+    branding?: MailTemplateOptions;
+}): {
+    html: string;
+    text: string;
+};
+/** Pre-built and custom transactional templates library. */
+export declare function renderEmailTemplate(templateName: EmailTemplateName, data?: Record<string, any>, branding?: MailTemplateOptions): Promise<{
+    html: string;
+    text: string;
+    subject?: string;
+}>;