@jant/core 0.3.43 → 0.3.45

package/src/lib/github-sync-queue-handler.ts

@@ -1,69 +0,0 @@
-/**
- * Cloudflare Queue batch handler for GitHub Sync jobs.
- *
- * This module bridges the CF Queue consumer interface with the
- * generic sync worker. It creates a runtime per-batch to access
- * services and configuration.
- */
-
-import { createRequestRuntime } from "../runtime/index.js";
-import { processGitHubSyncJob } from "./github-sync-worker.js";
-import { getGitHubAppConfig } from "./env.js";
-import type { JobPayload } from "./job-queue.js";
-import type { Bindings } from "../types/bindings.js";
-
-/**
- * Handle a batch of messages from a Cloudflare Queue.
- *
- * Each message is expected to be a `JobPayload` object.
- */
-export async function handleQueueBatch(
-  batch: MessageBatch<unknown>,
-  env: Record<string, unknown>,
-): Promise<void> {
-  // We need a runtime to access services. Use a synthetic URL since
-  // queue handlers don't have an incoming request.
-  const siteOrigin =
-    typeof env.SITE_ORIGIN === "string" && env.SITE_ORIGIN
-      ? env.SITE_ORIGIN
-      : "http://localhost";
-
-  const runtime = await createRequestRuntime(env as Bindings, siteOrigin);
-
-  for (const message of batch.messages) {
-    const payload = message.body as JobPayload;
-    try {
-      await processGitHubSyncJob(
-        payload,
-        runtime.services,
-        payload.siteId,
-        {
-          siteName: "",
-          siteUrl: siteOrigin,
-          siteDescription: "",
-          siteLanguage: "",
-          showJantBrandingOnHome: false,
-          homeDefaultView: "",
-          mainRssFeed: "",
-          siteFooter: "",
-          showHeaderAvatar: false,
-          siteAvatarUrl: "",
-          themeId: "",
-          defaultThemeId: "",
-          fontThemeId: "",
-          themeMode: "",
-          noindex: false,
-          navItems: [],
-          pageSize: 50,
-          archivePageSize: 50,
-          rssFeedLimit: 50,
-        },
-        runtime.storage,
-        getGitHubAppConfig(env),
-      );
-      message.ack();
-    } catch {
-      message.retry();
-    }
-  }
-}

package/src/lib/github-sync-worker.ts

@@ -1,72 +0,0 @@
-/**
- * GitHub Sync Worker
- *
- * Processes queued sync jobs. Push jobs always run a full sync.
- * After completing, re-checks the pending flag to catch changes
- * that arrived during execution.
- */
-
-import { createGitHubSyncService } from "../services/github-sync.js";
-import type { SiteConfig } from "../services/export.js";
-import type { Services } from "../services/index.js";
-import type { StorageDriver } from "../lib/storage.js";
-import type { GitHubAppEnvConfig } from "./env.js";
-import type { JobPayload } from "./job-queue.js";
-
-/**
- * Process a single GitHub Sync job.
- */
-export async function processGitHubSyncJob(
-  payload: JobPayload,
-  services: Services,
-  siteId: string,
-  siteConfig: SiteConfig,
-  storage?: StorageDriver | null,
-  githubApp?: GitHubAppEnvConfig | null,
-): Promise<void> {
-  const syncService = createGitHubSyncService(
-    {
-      posts: services.posts,
-      paths: services.paths,
-      collections: services.collections,
-      media: services.media,
-      settings: services.settings,
-    },
-    siteId,
-    siteConfig,
-    { storage, githubApp },
-  );
-
-  if (payload.kind === "github-sync-push") {
-    // Clear pending flag before running so new triggers during
-    // execution will set it again.
-    await services.settings.set("GITHUB_SYNC_PENDING", "");
-
-    await syncService.pushFullSync();
-
-    // If the flag was re-set during execution, run once more
-    const stillPending = await services.settings.get("GITHUB_SYNC_PENDING");
-    if (stillPending === "true") {
-      await services.settings.set("GITHUB_SYNC_PENDING", "");
-      await syncService.pushFullSync();
-    }
-    return;
-  }
-
-  if (payload.kind === "github-sync-pull") {
-    const webhookPayload = payload.data as {
-      ref: string;
-      before: string;
-      after: string;
-      commits: Array<{
-        id: string;
-        message: string;
-        added: string[];
-        modified: string[];
-        removed: string[];
-      }>;
-    };
-    await syncService.handleWebhookPush(webhookPayload);
-    return;
-  }
-}

package/src/lib/job-queue-cf.ts

@@ -1,18 +0,0 @@
-/**
- * Cloudflare Queue adapter for the job queue.
- */
-
-import type { JobPayload, JobQueue } from "./job-queue.js";
-
-/**
- * Create a job queue backed by a Cloudflare Queue binding.
- *
- * @param queue - The CF Queue binding (e.g. `env.GITHUB_SYNC_QUEUE`)
- */
-export function createCfJobQueue(queue: Queue): JobQueue {
-  return {
-    async enqueue(payload: JobPayload) {
-      await queue.send(payload);
-    },
-  };
-}

package/src/lib/job-queue-db.ts

@@ -1,149 +0,0 @@
-/**
- * Database-backed job queue.
- *
- * Used as a fallback when Cloudflare Queues are not available (e.g. Node/Postgres
- * or self-hosted deployments). Jobs are stored in the `sync_job` table and
- * processed via periodic polling.
- */
-
-import { eq, and, lte, sql } from "drizzle-orm";
-import type { Database } from "../db/index.js";
-import type { DatabaseSchema } from "../db/schema-bundle.js";
-import type { JobPayload, JobQueue } from "./job-queue.js";
-import { typeidUnboxed } from "typeid-js";
-import { now as unixNow } from "./time.js";
-
-// ---------------------------------------------------------------------------
-// Queue (producer)
-// ---------------------------------------------------------------------------
-
-/**
- * Create a job queue backed by a database table.
- *
- * @param db - Drizzle database instance
- * @param schema - Database schema bundle
- */
-export function createDbJobQueue(
-  db: Database,
-  schema: DatabaseSchema,
-): JobQueue {
-  return {
-    async enqueue(payload: JobPayload) {
-      const now = unixNow();
-      await db.insert(schema.syncJobs).values({
-        id: typeidUnboxed("job"),
-        siteId: payload.siteId,
-        kind: payload.kind,
-        payload: JSON.stringify(payload.data),
-        status: "pending",
-        attempts: 0,
-        maxAttempts: 3,
-        createdAt: now,
-        updatedAt: now,
-        lockedUntil: null,
-      });
-    },
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Worker (consumer) — poll-based dequeue
-// ---------------------------------------------------------------------------
-
-export interface DbJobWorkerOptions {
-  db: Database;
-  schema: DatabaseSchema;
-  /** Called to process each dequeued job. */
-  handler: (payload: JobPayload) => Promise<void>;
-  /** Lock duration in seconds. Defaults to 60. */
-  lockDurationSec?: number;
-}
-
-/**
- * Dequeue and process a single pending job.
- *
- * @returns `true` if a job was processed, `false` if the queue was empty.
- */
-export async function dequeueAndProcess(
-  opts: DbJobWorkerOptions,
-): Promise<boolean> {
-  const { db, schema, handler, lockDurationSec = 60 } = opts;
-  const now = unixNow();
-
-  // Find one eligible job (pending or timed-out lock)
-  const [job] = await db
-    .select()
-    .from(schema.syncJobs)
-    .where(
-      and(
-        eq(schema.syncJobs.status, "pending"),
-        sql`(${schema.syncJobs.lockedUntil} IS NULL OR ${schema.syncJobs.lockedUntil} <= ${now})`,
-      ),
-    )
-    .orderBy(schema.syncJobs.createdAt)
-    .limit(1);
-
-  if (!job) return false;
-
-  // Lock the job
-  await db
-    .update(schema.syncJobs)
-    .set({
-      status: "processing",
-      lockedUntil: now + lockDurationSec,
-      attempts: job.attempts + 1,
-      updatedAt: now,
-    })
-    .where(eq(schema.syncJobs.id, job.id));
-
-  try {
-    const payload: JobPayload = {
-      kind: job.kind as JobPayload["kind"],
-      siteId: job.siteId,
-      data: JSON.parse(job.payload) as Record<string, unknown>,
-    };
-    await handler(payload);
-
-    // Mark completed
-    await db
-      .update(schema.syncJobs)
-      .set({ status: "completed", updatedAt: unixNow() })
-      .where(eq(schema.syncJobs.id, job.id));
-  } catch {
-    const updatedAttempts = job.attempts + 1;
-    const maxAttempts = job.maxAttempts;
-
-    await db
-      .update(schema.syncJobs)
-      .set({
-        status: updatedAttempts >= maxAttempts ? "failed" : "pending",
-        lockedUntil: null,
-        updatedAt: unixNow(),
-      })
-      .where(eq(schema.syncJobs.id, job.id));
-  }
-
-  return true;
-}
-
-/**
- * Clean up completed and failed jobs older than the given age.
- *
- * @param maxAgeSec - Maximum age in seconds. Defaults to 7 days.
- */
-export async function cleanupOldJobs(
-  db: Database,
-  schema: DatabaseSchema,
-  maxAgeSec = 7 * 24 * 3600,
-): Promise<number> {
-  const cutoff = unixNow() - maxAgeSec;
-  const result = await db
-    .delete(schema.syncJobs)
-    .where(
-      and(
-        sql`${schema.syncJobs.status} IN ('completed', 'failed')`,
-        lte(schema.syncJobs.updatedAt, cutoff),
-      ),
-    );
-  return (result as { rowsAffected?: number }).rowsAffected ?? 0;
-}

package/src/lib/job-queue.ts

@@ -1,35 +0,0 @@
-/**
- * Job Queue abstraction.
- *
- * Provides a unified interface for enqueueing background jobs across
- * Cloudflare Workers (CF Queues) and Node/Postgres (DB-backed polling).
- */
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export type JobKind = "github-sync-push" | "github-sync-pull";
-
-export interface JobPayload {
-  kind: JobKind;
-  siteId: string;
-  data: Record<string, unknown>;
-}
-
-export interface JobQueue {
-  /** Enqueue a job for async background processing. */
-  enqueue(payload: JobPayload): Promise<void>;
-}
-
-// ---------------------------------------------------------------------------
-// Noop Queue (used when no queue backend is available)
-// ---------------------------------------------------------------------------
-
-/**
- * A no-op queue that silently drops jobs.
- * Used as a fallback when neither CF Queue nor DB queue is configured.
- */
-export const noopQueue: JobQueue = {
-  async enqueue() {},
-};