editor-ts 0.0.10 → 0.0.12

package/src/server/bun_server.ts

@@ -0,0 +1,155 @@
+import type { Database } from 'bun:sqlite';
+import type { Server } from 'bun';
+import type { PageMeta, PageMetaStore } from './sync';
+import type { EditorTsSyncMessage } from '../types';
+import { createSyncAck, isSyncMessage, parseSyncEnvelope } from './sync';
+
+export interface BunSyncServer {
+  server: Server<unknown>;
+  close: () => void;
+}
+
+export const createBunPageMetaStore = (database: Database): PageMetaStore => {
+  const init = () => {
+    database.query(
+      `
+      CREATE TABLE IF NOT EXISTS editorts_page_meta (
+        key TEXT PRIMARY KEY,
+        title TEXT NOT NULL,
+        item_id INTEGER NOT NULL,
+        updated_at TEXT NOT NULL
+      )
+    `
+    ).run();
+  };
+
+  const toRow = (meta: PageMeta) => ({
+    key: meta.key,
+    title: meta.title,
+    item_id: meta.itemId,
+    updated_at: meta.updatedAt,
+  });
+
+  const fromRow = (row: {
+    key: string;
+    title: string;
+    item_id: number;
+    updated_at: string;
+  }): PageMeta => ({
+    key: row.key,
+    title: row.title,
+    itemId: row.item_id,
+    updatedAt: row.updated_at,
+  });
+
+  init();
+
+  return {
+    async save(meta) {
+      const row = toRow(meta);
+      database
+        .query(
+          `
+          INSERT INTO editorts_page_meta (key, title, item_id, updated_at)
+          VALUES ($key, $title, $item_id, $updated_at)
+          ON CONFLICT(key) DO UPDATE SET
+            title = excluded.title,
+            item_id = excluded.item_id,
+            updated_at = excluded.updated_at
+        `
+        )
+        .run(row);
+    },
+    async get(key) {
+      const row = database
+        .query(
+          `
+          SELECT key, title, item_id, updated_at
+          FROM editorts_page_meta
+          WHERE key = $key
+        `
+        )
+        .get({ key }) as
+        | {
+            key: string;
+            title: string;
+            item_id: number;
+            updated_at: string;
+          }
+        | null;
+
+      return row ? fromRow(row) : null;
+    },
+    async list() {
+      const rows = database
+        .query(
+          `
+          SELECT key, title, item_id, updated_at
+          FROM editorts_page_meta
+          ORDER BY updated_at DESC
+        `
+        )
+        .all() as Array<{ key: string; title: string; item_id: number; updated_at: string }>;
+
+      return rows.map((row) => fromRow(row));
+    },
+    async delete(key) {
+      database
+        .query(
+          `
+          DELETE FROM editorts_page_meta
+          WHERE key = $key
+        `
+        )
+        .run({ key });
+    },
+  };
+};
+
+export const createBunSyncServer = (options?: {
+  port?: number;
+  onSync?: (message: EditorTsSyncMessage) => Promise<void> | void;
+}): BunSyncServer => {
+  const port = options?.port ?? 8787;
+  const onSync = options?.onSync;
+
+  const server = Bun.serve({
+    port,
+    fetch(req) {
+      const upgradeHeader = req.headers.get('upgrade');
+      if (upgradeHeader?.toLowerCase() !== 'websocket') {
+        return new Response('Upgrade required', { status: 426 });
+      }
+
+      if (!server.upgrade(req)) {
+        return new Response('Websocket upgrade failed', { status: 400 });
+      }
+
+      return new Response(null, { status: 101 });
+    },
+    websocket: {
+      open(ws) {
+        ws.send(JSON.stringify(createSyncAck('connected')));
+      },
+      async message(ws, data) {
+        const text = typeof data === 'string' ? data : new TextDecoder().decode(data as BufferSource);
+        const envelope = parseSyncEnvelope(text);
+        if (!envelope || !isSyncMessage(envelope)) {
+          ws.send(JSON.stringify(createSyncAck('invalid-payload')));
+          return;
+        }
+
+        if (onSync) {
+          await onSync(envelope);
+        }
+
+        ws.send(JSON.stringify(createSyncAck(envelope.key ?? 'page')));
+      },
+    },
+  });
+
+  return {
+    server,
+    close: () => server.stop(true),
+  };
+};

package/src/server/cf_worker.ts

@@ -0,0 +1,225 @@
+import type { PageMeta, PageMetaStore } from './sync';
+import type { EditorTsSyncMessage } from '../types';
+import { createSyncAck, isSyncMessage, parseSyncEnvelope } from './sync';
+
+type DurableObjectNamespace = {
+  idFromName(name: string): DurableObjectId;
+  get(id: DurableObjectId): DurableObjectStub;
+};
+
+type DurableObjectId = {
+  toString(): string;
+};
+
+type DurableObjectStub = {
+  fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
+};
+
+type DurableObjectStorage = {
+  get<T>(key: string): Promise<T | undefined>;
+  put<T>(key: string, value: T): Promise<void>;
+  delete(key: string): Promise<void>;
+};
+
+type DurableObjectState = {
+  id: DurableObjectId;
+  storage: DurableObjectStorage;
+};
+
+type DurableObject = {
+  fetch(request: Request): Promise<Response>;
+};
+
+export const createCfPageMetaStore = (namespace: DurableObjectNamespace): PageMetaStore => {
+  return {
+    async save(meta) {
+      const id = namespace.idFromName(meta.key);
+      const stub = namespace.get(id);
+      await stub.fetch('https://editor-ts.local/meta', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify(meta),
+      });
+    },
+    async get(key) {
+      const id = namespace.idFromName(key);
+      const stub = namespace.get(id);
+      const response = await stub.fetch('https://editor-ts.local/meta');
+      if (response.status === 404) return null;
+      if (!response.ok) {
+        throw new Error(`Failed to fetch page meta: ${response.statusText}`);
+      }
+      return (await response.json()) as PageMeta;
+    },
+    async list() {
+      const id = namespace.idFromName('index');
+      const stub = namespace.get(id);
+      const response = await stub.fetch('https://editor-ts.local/meta/index');
+      if (!response.ok) {
+        throw new Error(`Failed to list page meta: ${response.statusText}`);
+      }
+      return (await response.json()) as PageMeta[];
+    },
+    async delete(key) {
+      const id = namespace.idFromName(key);
+      const stub = namespace.get(id);
+      const response = await stub.fetch('https://editor-ts.local/meta', {
+        method: 'DELETE',
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to delete page meta: ${response.statusText}`);
+      }
+    },
+  };
+};
+
+export class EditorTsPageMetaDurableObject implements DurableObject {
+  constructor(private state: DurableObjectState, private env: Env) {}
+
+  async fetch(request: Request): Promise<Response> {
+    const url = new URL(request.url);
+    if (url.pathname === '/meta/index' && request.method === 'GET') {
+      const list = (await this.state.storage.get<PageMeta[]>('index')) ?? [];
+      return new Response(JSON.stringify(list), {
+        headers: { 'content-type': 'application/json' },
+      });
+    }
+
+    if (url.pathname !== '/meta') {
+      return new Response('Not found', { status: 404 });
+    }
+
+    if (request.method === 'GET') {
+      const meta = await this.state.storage.get<PageMeta>('meta');
+      if (!meta) return new Response('Not found', { status: 404 });
+      return new Response(JSON.stringify(meta), {
+        headers: { 'content-type': 'application/json' },
+      });
+    }
+
+    if (request.method === 'POST') {
+      const meta = (await request.json()) as PageMeta;
+      await this.state.storage.put('meta', meta);
+
+      const indexId = this.env.EDITOR_TS_META.idFromName('index');
+      const indexStub = this.env.EDITOR_TS_META.get(indexId);
+      await indexStub.fetch('https://editor-ts.local/meta/index', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify(meta),
+      });
+
+      return new Response('ok');
+    }
+
+    if (request.method === 'DELETE') {
+      await this.state.storage.delete('meta');
+
+      const indexId = this.env.EDITOR_TS_META.idFromName('index');
+      const indexStub = this.env.EDITOR_TS_META.get(indexId);
+      await indexStub.fetch('https://editor-ts.local/meta/index', {
+        method: 'DELETE',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ key: this.state.id.toString() }),
+      });
+
+      return new Response('ok');
+    }
+
+    return new Response('Method not allowed', { status: 405 });
+  }
+}
+
+export class EditorTsPageMetaIndexDurableObject implements DurableObject {
+  constructor(private state: DurableObjectState) {}
+
+  async fetch(request: Request): Promise<Response> {
+    const url = new URL(request.url);
+    if (url.pathname !== '/meta/index') {
+      return new Response('Not found', { status: 404 });
+    }
+
+    if (request.method === 'GET') {
+      const list = (await this.state.storage.get<PageMeta[]>('index')) ?? [];
+      return new Response(JSON.stringify(list), {
+        headers: { 'content-type': 'application/json' },
+      });
+    }
+
+    if (request.method === 'POST') {
+      const meta = (await request.json()) as PageMeta;
+      const list = (await this.state.storage.get<PageMeta[]>('index')) ?? [];
+      const next = list.filter((entry: PageMeta) => entry.key !== meta.key);
+      next.push(meta);
+      next.sort((a: PageMeta, b: PageMeta) => b.updatedAt.localeCompare(a.updatedAt));
+      await this.state.storage.put('index', next);
+      return new Response('ok');
+    }
+
+    if (request.method === 'DELETE') {
+      const payload = (await request.json()) as { key?: string };
+      const key = payload.key ?? '';
+      const list = (await this.state.storage.get<PageMeta[]>('index')) ?? [];
+      const next = list.filter((entry: PageMeta) => entry.key !== key);
+      await this.state.storage.put('index', next);
+      return new Response('ok');
+    }
+
+    return new Response('Method not allowed', { status: 405 });
+  }
+}
+
+interface Env {
+  EDITOR_TS_META: DurableObjectNamespace;
+}
+
+export type { DurableObjectNamespace, DurableObject, DurableObjectState, DurableObjectStorage, DurableObjectId, DurableObjectStub };
+
+interface CloudflareWebSocketPair {
+  0: WebSocket;
+  1: WebSocket;
+}
+
+export type CfSyncEnv = Record<string, string | undefined>;
+
+export const createCfSyncWorker = (options?: {
+  onSync?: (message: EditorTsSyncMessage) => Promise<void> | void;
+}) => {
+  const onSync = options?.onSync;
+
+  return {
+    fetch(request: Request, _env: CfSyncEnv): Response {
+      if (request.headers.get('upgrade')?.toLowerCase() !== 'websocket') {
+        return new Response('Upgrade required', { status: 426 });
+      }
+
+      const pair = new (((globalThis as unknown) as { WebSocketPair: { new(): CloudflareWebSocketPair } }).WebSocketPair)();
+      const client = pair[0];
+      const server = pair[1];
+
+      const serverSocket = server as WebSocket & { accept?: () => void };
+      serverSocket.accept?.();
+      server.send(JSON.stringify(createSyncAck('connected')));
+
+      server.addEventListener('message', async (event) => {
+        const data = typeof event.data === 'string' ? event.data : new TextDecoder().decode(event.data as ArrayBuffer);
+        const envelope = parseSyncEnvelope(data);
+        if (!envelope || !isSyncMessage(envelope)) {
+          server.send(JSON.stringify(createSyncAck('invalid-payload')));
+          return;
+        }
+
+        if (onSync) {
+          await onSync(envelope);
+        }
+
+        server.send(JSON.stringify(createSyncAck(envelope.key ?? 'page')));
+      });
+
+      return new Response(null, {
+        status: 101,
+        webSocket: client,
+      } as ResponseInit);
+    },
+  };
+};

package/src/server/schema.ts

@@ -0,0 +1,21 @@
+import { integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+
+export const pages = sqliteTable('pages', {
+  id: integer('id').primaryKey({ autoIncrement: true }),
+  key: text('key').notNull().unique(),
+  title: text('title').notNull(),
+  itemId: integer('item_id').notNull(),
+  body: text('body').notNull(),
+  createdAt: integer('created_at', { mode: 'timestamp_ms' }).notNull(),
+  updatedAt: integer('updated_at', { mode: 'timestamp_ms' }).notNull(),
+});
+
+export const pageFiles = sqliteTable('page_files', {
+  id: integer('id').primaryKey({ autoIncrement: true }),
+  pageId: integer('page_id')
+    .notNull()
+    .references(() => pages.id, { onDelete: 'cascade' }),
+  path: text('path').notNull(),
+  content: text('content').notNull(),
+  updatedAt: integer('updated_at', { mode: 'timestamp_ms' }).notNull(),
+});

package/src/server/sync.ts

@@ -0,0 +1,195 @@
+import type { StorageAdapter } from '../core/StorageManager';
+import type { PageData, EditorTsSyncAck, EditorTsSyncEnvelope, EditorTsSyncMessage, PagePayload } from '../types';
+
+export type ServerPageMeta = {
+  key: string;
+  updatedAt: number;
+  checksum?: string;
+};
+
+export type ServerFile = {
+  path: string;
+  content: string;
+};
+
+export type ServerSyncAdapter = {
+  listPages(): Promise<ServerPageMeta[]>;
+  listFiles(pageKey: string): Promise<ServerFile[]>;
+  saveFiles(pageKey: string, files: ServerFile[]): Promise<void>;
+};
+
+export type FrontendSyncOptions = {
+  pageKey: string;
+  storage: StorageAdapter;
+  adapter: ServerSyncAdapter;
+  includeFiles?: (path: string) => boolean;
+  onStatus?: (status: FrontendSyncStatus) => void;
+};
+
+export type FrontendSyncStatus =
+  | { state: 'loading' }
+  | { state: 'saving' }
+  | { state: 'idle' }
+  | { state: 'error'; message: string };
+
+export interface PageMeta {
+  key: string;
+  title: string;
+  itemId: number;
+  updatedAt: string;
+}
+
+export interface PageMetaStore {
+  save(meta: PageMeta): Promise<void>;
+  get(key: string): Promise<PageMeta | null>;
+  list(): Promise<PageMeta[]>;
+  delete(key: string): Promise<void>;
+}
+
+const defaultIncludeFiles = (path: string): boolean => {
+  return path === 'page.json' || path === 'styles.css' || path === 'index.html' || path.startsWith('components/');
+};
+
+const safeParseJson = <T>(raw: string | null): T | null => {
+  if (!raw) return null;
+  try {
+    return JSON.parse(raw) as T;
+  } catch {
+    return null;
+  }
+};
+
+const encodeStorageKey = (pageKey: string, path: string): string => {
+  return `${pageKey}:${path}`;
+};
+
+const decodeStorageKey = (pageKey: string, storageKey: string): string => {
+  return storageKey.replace(`${pageKey}:`, '');
+};
+
+const computeChecksum = (content: string): string => {
+  let hash = 2166136261;
+  for (let i = 0; i < content.length; i += 1) {
+    hash ^= content.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16);
+};
+
+const updateStatus = (options: FrontendSyncOptions, status: FrontendSyncStatus) => {
+  options.onStatus?.(status);
+};
+
+export const syncFrontendWithServer = async (options: FrontendSyncOptions): Promise<void> => {
+  const { pageKey, storage, adapter } = options;
+  const includeFiles = options.includeFiles ?? defaultIncludeFiles;
+
+  try {
+    updateStatus(options, { state: 'loading' });
+
+    const remotePages = await adapter.listPages();
+    const remoteMeta = remotePages.find((page) => page.key === pageKey);
+
+    const localMetaKey = encodeStorageKey(pageKey, 'meta');
+    const localMeta = safeParseJson<ServerPageMeta>(await storage.loadPage(localMetaKey));
+
+    if (remoteMeta && (!localMeta || remoteMeta.updatedAt > localMeta.updatedAt)) {
+      const remoteFiles = await adapter.listFiles(pageKey);
+      const filtered = remoteFiles.filter((file) => includeFiles(file.path));
+
+      await Promise.all(
+        filtered.map(async (file) => {
+          await storage.savePage(encodeStorageKey(pageKey, file.path), file.content);
+        })
+      );
+
+      await storage.savePage(localMetaKey, JSON.stringify(remoteMeta));
+      updateStatus(options, { state: 'idle' });
+      return;
+    }
+
+    updateStatus(options, { state: 'saving' });
+
+    const storedKeys = await storage.listPages();
+    const pageKeys = storedKeys.filter((key) => key.startsWith(`${pageKey}:`));
+
+    const fileKeys = pageKeys.filter((key) => {
+      const path = decodeStorageKey(pageKey, key);
+      return path !== 'meta' && includeFiles(path);
+    });
+
+    const files = await Promise.all(
+      fileKeys.map(async (key) => {
+        const content = (await storage.loadPage(key)) ?? '';
+        return {
+          path: decodeStorageKey(pageKey, key),
+          content,
+        };
+      })
+    );
+
+    await adapter.saveFiles(pageKey, files);
+
+    const payload: ServerPageMeta = {
+      key: pageKey,
+      updatedAt: Date.now(),
+      checksum: computeChecksum(files.map((file) => file.content).join('|')),
+    };
+
+    await storage.savePage(localMetaKey, JSON.stringify(payload));
+    updateStatus(options, { state: 'idle' });
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err);
+    updateStatus(options, { state: 'error', message });
+  }
+};
+
+export const createPageMeta = (
+  key: string,
+  page: PageData,
+  options?: { updatedAt?: string }
+): PageMeta => {
+  return {
+    key,
+    title: page.title,
+    itemId: page.item_id,
+    updatedAt: options?.updatedAt ?? new Date().toISOString(),
+  };
+};
+
+export const isSyncMessage = (message: EditorTsSyncEnvelope): message is EditorTsSyncMessage => {
+  return message.type === 'page';
+};
+
+export const isSyncAck = (message: EditorTsSyncEnvelope): message is EditorTsSyncAck => {
+  return message.type === 'ack';
+};
+
+export const createSyncMessage = (payload: PagePayload, options?: { key?: string }): EditorTsSyncMessage => {
+  return {
+    type: 'page',
+    payload,
+    key: options?.key,
+    sentAt: new Date().toISOString(),
+  };
+};
+
+export const createSyncAck = (messageId: string): EditorTsSyncAck => {
+  return {
+    type: 'ack',
+    messageId,
+    receivedAt: new Date().toISOString(),
+  };
+};
+
+export const parseSyncEnvelope = (raw: string): EditorTsSyncEnvelope | null => {
+  try {
+    const parsed = JSON.parse(raw) as EditorTsSyncEnvelope;
+    if (parsed && (parsed.type === 'page' || parsed.type === 'ack')) {
+      return parsed;
+    }
+  } catch (error: unknown) {
+    return null;
+  }
+  return null;
+};

package/src/types/sqlocal.d.ts

@@ -0,0 +1,6 @@
+declare module 'sqlocal' {
+  export class SQLocal {
+    constructor(databaseName: string);
+    sql(strings: TemplateStringsArray, ...values: unknown[]): Promise<Array<Record<string, unknown>>>;
+  }
+}