@takosjp/yurucommu-core 3.0.0

package/src/backend/runtime/cloudflare.ts

@@ -0,0 +1,202 @@
+/**
+ * Cloudflare Workers Runtime Adapters
+ *
+ * These adapters wrap Cloudflare-specific APIs to conform to the runtime interfaces.
+ */
+
+import type {
+  D1Database,
+  Fetcher,
+  KVNamespace,
+  R2Bucket,
+  R2Object,
+} from "@cloudflare/workers-types";
+import { getDb } from "../../db/index.ts";
+import type {
+  IKeyValueStore,
+  IObjectStorage,
+  IStaticAssets,
+  ListObjectsResult,
+  ObjectMetadata,
+  StorageObject,
+} from "./types.ts";
+
+/**
+ * Cloudflare R2 Storage Adapter
+ */
+class CloudflareStorage implements IObjectStorage {
+  constructor(private bucket: R2Bucket) {}
+
+  async put(
+    key: string,
+    value: ReadableStream | ArrayBuffer | string,
+    options?: {
+      httpMetadata?: ObjectMetadata["httpMetadata"];
+      customMetadata?: Record<string, string>;
+    },
+  ): Promise<void> {
+    await this.bucket.put(key, value as Parameters<R2Bucket["put"]>[1], {
+      httpMetadata: options?.httpMetadata,
+      customMetadata: options?.customMetadata,
+    });
+  }
+
+  async get(key: string): Promise<StorageObject | null> {
+    const obj = await this.bucket.get(key);
+    if (!obj) return null;
+
+    return {
+      key,
+      body: obj.body as unknown as ReadableStream,
+      bodyUsed: obj.bodyUsed,
+      httpEtag: obj.httpEtag,
+      arrayBuffer: () => obj.arrayBuffer(),
+      text: () => obj.text(),
+      json: <T>() => obj.json<T>(),
+      httpMetadata: obj.httpMetadata,
+      customMetadata: obj.customMetadata,
+    };
+  }
+
+  async delete(key: string | string[]): Promise<void> {
+    await this.bucket.delete(key);
+  }
+
+  async list(options?: {
+    prefix?: string;
+    limit?: number;
+    cursor?: string;
+    delimiter?: string;
+  }): Promise<ListObjectsResult> {
+    const result = await this.bucket.list(options);
+    return {
+      objects: result.objects.map((obj: R2Object) => ({
+        key: obj.key,
+        size: obj.size,
+        uploaded: obj.uploaded,
+        etag: obj.etag,
+        httpMetadata: obj.httpMetadata,
+      })),
+      truncated: result.truncated,
+      cursor: result.truncated ? result.cursor : undefined,
+      delimitedPrefixes: result.delimitedPrefixes,
+    };
+  }
+
+  async head(key: string): Promise<ObjectMetadata | null> {
+    const obj = await this.bucket.head(key);
+    if (!obj) return null;
+
+    return {
+      contentType: obj.httpMetadata?.contentType,
+      contentLength: obj.size,
+      etag: obj.etag,
+      httpMetadata: obj.httpMetadata,
+      customMetadata: obj.customMetadata,
+    };
+  }
+}
+
+/**
+ * Cloudflare KV Adapter
+ */
+class CloudflareKV implements IKeyValueStore {
+  constructor(private kv: KVNamespace) {}
+
+  get(key: string, options?: { type?: "text" }): Promise<string | null>;
+  get<T = unknown>(key: string, options: { type: "json" }): Promise<T | null>;
+  get(
+    key: string,
+    options: { type: "arrayBuffer" },
+  ): Promise<ArrayBuffer | null>;
+  async get(
+    key: string,
+    options?: { type?: "text" | "json" | "arrayBuffer" },
+  ): Promise<string | ArrayBuffer | unknown | null> {
+    const type = options?.type ?? "text";
+    if (type === "json") return this.kv.get(key, { type: "json" });
+    if (type === "arrayBuffer") {
+      return this.kv.get(key, { type: "arrayBuffer" });
+    }
+    return this.kv.get(key, { type: "text" });
+  }
+
+  async put(
+    key: string,
+    value: string | ArrayBuffer | ReadableStream,
+    options?: {
+      expirationTtl?: number;
+      expiration?: number;
+      metadata?: Record<string, unknown>;
+    },
+  ): Promise<void> {
+    await this.kv.put(key, value as Parameters<KVNamespace["put"]>[1], {
+      expirationTtl: options?.expirationTtl,
+      expiration: options?.expiration,
+      metadata: options?.metadata,
+    });
+  }
+
+  async delete(key: string): Promise<void> {
+    await this.kv.delete(key);
+  }
+
+  async list(options?: {
+    prefix?: string;
+    limit?: number;
+    cursor?: string;
+  }): Promise<{
+    keys: Array<{ name: string; expiration?: number; metadata?: unknown }>;
+    list_complete: boolean;
+    cursor?: string;
+  }> {
+    const result = await this.kv.list(options);
+    return {
+      keys: result.keys,
+      list_complete: result.list_complete,
+      cursor: result.list_complete ? undefined : result.cursor,
+    };
+  }
+}
+
+/**
+ * Cloudflare Static Assets Adapter
+ */
+class CloudflareAssets implements IStaticAssets {
+  constructor(private assets: Fetcher) {}
+
+  fetch(request: Request): Promise<Response> {
+    return this.assets.fetch(request as never) as unknown as Promise<Response>;
+  }
+}
+
+/**
+ * Wrap a native Cloudflare Workers binding env into the app's runtime
+ * `Env` shape. The Hono app and all helper functions speak the runtime
+ * `I*` contracts, so every binding flows through this adapter before
+ * reaching app code. Pre-creates the drizzle wrapper as `DB_INSTANCE`.
+ */
+export function wrapCloudflareBindings<
+  T extends {
+    DB: D1Database;
+    MEDIA?: R2Bucket;
+    KV: KVNamespace;
+    ASSETS?: Fetcher;
+  },
+>(
+  bindings: T,
+): Omit<T, "DB" | "MEDIA" | "KV" | "ASSETS"> & {
+  DB_INSTANCE: ReturnType<typeof getDb>;
+  MEDIA?: IObjectStorage;
+  KV: IKeyValueStore;
+  ASSETS?: IStaticAssets;
+} {
+  const { DB, MEDIA, KV, ASSETS, ...rest } = bindings;
+  return {
+    ...rest,
+    DB_INSTANCE: getDb(DB),
+    MEDIA: MEDIA ? new CloudflareStorage(MEDIA) : undefined,
+    KV: new CloudflareKV(KV),
+    ASSETS: ASSETS ? new CloudflareAssets(ASSETS) : undefined,
+  };
+}

package/src/backend/runtime/compat-bun/types.ts

@@ -0,0 +1,44 @@
+export type BunSQLiteRunResult = {
+  changes: number;
+  lastInsertRowid: number;
+};
+
+export interface BunSQLiteStatement {
+  get(...values: unknown[]): unknown;
+  all(...values: unknown[]): unknown[];
+  run(...values: unknown[]): BunSQLiteRunResult;
+}
+
+export interface BunSQLiteDatabase {
+  exec(query: string): void;
+  prepare(query: string): BunSQLiteStatement;
+  transaction(callback: () => void): () => void;
+}
+
+export interface BunSQLiteDatabaseConstructor {
+  new (filename: string): BunSQLiteDatabase;
+}
+
+export type BunFile = BodyInit & {
+  readonly size: number;
+  exists(): Promise<boolean>;
+  arrayBuffer(): Promise<ArrayBuffer>;
+  text(): Promise<string>;
+};
+
+type BunWriteData =
+  Blob | string | ArrayBufferLike | ArrayBufferView<ArrayBufferLike>;
+
+export interface BunRuntime {
+  file(path: string): BunFile;
+  write(path: string, data: BunWriteData): Promise<number>;
+}
+
+export function loadBunSqlite(
+  runtimeRequire: (specifier: string) => unknown,
+): BunSQLiteDatabaseConstructor {
+  const sqliteModule = runtimeRequire("bun:sqlite") as {
+    Database: BunSQLiteDatabaseConstructor;
+  };
+  return sqliteModule.Database;
+}

package/src/backend/runtime/memory-kv.ts

@@ -0,0 +1,104 @@
+import type { IKeyValueStore } from "./types.ts";
+import {
+  DEFAULT_LIST_LIMIT,
+  nowSeconds,
+  paginateList,
+  readStream,
+  resolveExpiration,
+} from "./shared.ts";
+
+export class MemoryKV implements IKeyValueStore {
+  private store = new Map<
+    string,
+    { value: string; expiration?: number; metadata?: Record<string, unknown> }
+  >();
+
+  get(key: string, options?: { type?: "text" }): Promise<string | null>;
+  get<T = unknown>(key: string, options: { type: "json" }): Promise<T | null>;
+  get(
+    key: string,
+    options: { type: "arrayBuffer" },
+  ): Promise<ArrayBuffer | null>;
+  async get(
+    key: string,
+    options?: { type?: "text" | "json" | "arrayBuffer" },
+  ): Promise<string | ArrayBuffer | unknown | null> {
+    const entry = this.store.get(key);
+    if (!entry) return null;
+
+    if (entry.expiration && entry.expiration < nowSeconds()) {
+      this.store.delete(key);
+      return null;
+    }
+
+    const type = options?.type ?? "text";
+    if (type === "json") return JSON.parse(entry.value);
+    if (type === "arrayBuffer") {
+      return new TextEncoder().encode(entry.value).buffer;
+    }
+    return entry.value;
+  }
+
+  async put(
+    key: string,
+    value: string | ArrayBuffer | ReadableStream,
+    options?: {
+      expirationTtl?: number;
+      expiration?: number;
+      metadata?: Record<string, unknown>;
+    },
+  ): Promise<void> {
+    let strValue: string;
+    if (typeof value === "string") {
+      strValue = value;
+    } else if (value instanceof ArrayBuffer) {
+      strValue = new TextDecoder().decode(value);
+    } else {
+      strValue = new TextDecoder().decode(await readStream(value));
+    }
+
+    this.store.set(key, {
+      value: strValue,
+      expiration: resolveExpiration(options),
+      metadata: options?.metadata,
+    });
+  }
+
+  async delete(key: string): Promise<void> {
+    this.store.delete(key);
+  }
+
+  async list(options?: {
+    prefix?: string;
+    limit?: number;
+    cursor?: string;
+  }): Promise<{
+    keys: Array<{ name: string; expiration?: number; metadata?: unknown }>;
+    list_complete: boolean;
+    cursor?: string;
+  }> {
+    const keys: Array<{
+      name: string;
+      expiration?: number;
+      metadata?: unknown;
+    }> = [];
+    const now = nowSeconds();
+
+    for (const [name, entry] of this.store.entries()) {
+      if (entry.expiration && entry.expiration < now) continue;
+      if (options?.prefix && !name.startsWith(options.prefix)) continue;
+
+      keys.push({
+        name,
+        expiration: entry.expiration,
+        metadata: entry.metadata,
+      });
+    }
+
+    const { items, complete, cursor } = paginateList(
+      keys,
+      options?.limit ?? DEFAULT_LIST_LIMIT,
+    );
+    return { keys: items, list_complete: complete, cursor };
+  }
+}

package/src/backend/runtime/shared.ts

@@ -0,0 +1,142 @@
+import path from "node:path";
+
+export const DEFAULT_LIST_LIMIT = 1000;
+
+const FALLBACK_MIME = "application/octet-stream";
+
+const MIME_TYPES: Record<string, string> = {
+  ".html": "text/html",
+  ".css": "text/css",
+  ".js": "application/javascript",
+  ".json": "application/json",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".webp": "image/webp",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+};
+
+export function getMimeType(ext: string): string {
+  return MIME_TYPES[ext] || FALLBACK_MIME;
+}
+
+export function nowSeconds(): number {
+  return Date.now() / 1000;
+}
+
+export function hasNulByte(value: string): boolean {
+  return value.includes("\0");
+}
+
+export function isPathWithinBasePath(
+  basePath: string,
+  candidatePath: string,
+): boolean {
+  const relative = path.relative(basePath, candidatePath);
+  return (
+    relative === "" ||
+    (!relative.startsWith("..") && !path.isAbsolute(relative))
+  );
+}
+
+export function resolvePathWithinBasePath(
+  basePath: string,
+  key: string,
+): string {
+  if (hasNulByte(key)) {
+    throw new Error("Invalid path");
+  }
+  const resolvedPath = path.resolve(basePath, key);
+  if (!isPathWithinBasePath(basePath, resolvedPath)) {
+    throw new Error("Path escapes base directory");
+  }
+  return resolvedPath;
+}
+
+function isNotFoundError(error: unknown): boolean {
+  return (
+    typeof error === "object" &&
+    error !== null &&
+    "code" in error &&
+    (error as { code?: unknown }).code === "ENOENT"
+  );
+}
+
+export async function assertPathChainWithinBasePath(
+  basePath: string,
+  targetPath: string,
+  realpath: (path: string) => Promise<string>,
+): Promise<void> {
+  let currentPath = targetPath;
+
+  while (true) {
+    try {
+      const realCurrentPath = await realpath(currentPath);
+      if (!isPathWithinBasePath(basePath, realCurrentPath)) {
+        throw new Error("Path escapes base directory");
+      }
+      return;
+    } catch (error) {
+      if (!isNotFoundError(error)) {
+        throw error;
+      }
+      const parentPath = path.dirname(currentPath);
+      if (parentPath === currentPath) {
+        throw error;
+      }
+      currentPath = parentPath;
+    }
+  }
+}
+
+export async function readStream(
+  stream: ReadableStream<Uint8Array>,
+): Promise<Uint8Array> {
+  const reader = stream.getReader();
+  const chunks: Uint8Array[] = [];
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+  }
+
+  const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+  const combined = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    combined.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return combined;
+}
+
+export function resolveExpiration(options?: {
+  expiration?: number;
+  expirationTtl?: number;
+}): number | undefined {
+  if (options?.expiration) return options.expiration;
+  if (options?.expirationTtl) {
+    return Math.floor(nowSeconds()) + options.expirationTtl;
+  }
+  return undefined;
+}
+
+export function paginateList<T>(
+  items: T[],
+  limit: number,
+): { items: T[]; complete: boolean; cursor?: string } {
+  const complete = items.length <= limit;
+  return {
+    items: items.slice(0, limit),
+    complete,
+    cursor: complete ? undefined : String(limit),
+  };
+}

package/src/backend/runtime/types.ts

@@ -0,0 +1,205 @@
+/**
+ * Runtime Abstraction Types
+ *
+ * These interfaces abstract away Cloudflare Workers-specific APIs
+ * to allow the application to run on different runtimes.
+ */
+
+/**
+ * Shared metadata for query/run results
+ */
+export interface ResultMeta {
+  changes?: number;
+  last_row_id?: number;
+  duration?: number;
+}
+
+/**
+ * Database query result
+ */
+export interface QueryResult<T = unknown> {
+  results: T[];
+  success: boolean;
+  meta?: ResultMeta;
+}
+
+/**
+ * Single row result
+ */
+export type FirstResult<T> = T | null;
+
+/**
+ * Run result (for INSERT/UPDATE/DELETE)
+ */
+export interface RunResult {
+  success: boolean;
+  meta?: Pick<ResultMeta, "changes" | "last_row_id">;
+}
+
+/**
+ * Prepared statement interface
+ */
+export interface PreparedStatement {
+  bind(...values: unknown[]): PreparedStatement;
+  first<T = unknown>(colName?: string): Promise<FirstResult<T>>;
+  all<T = unknown>(): Promise<QueryResult<T>>;
+  run(): Promise<RunResult>;
+}
+
+/**
+ * Database interface - abstracts D1Database
+ */
+export interface IDatabase {
+  prepare(query: string): PreparedStatement;
+  exec(query: string): Promise<void>;
+  batch<T = unknown>(
+    statements: PreparedStatement[],
+  ): Promise<QueryResult<T>[]>;
+}
+
+/**
+ * Object storage metadata
+ */
+export interface ObjectMetadata {
+  contentType?: string;
+  contentLength?: number;
+  etag?: string;
+  httpMetadata?: {
+    contentType?: string;
+    cacheControl?: string;
+    contentDisposition?: string;
+    contentEncoding?: string;
+    contentLanguage?: string;
+  };
+  customMetadata?: Record<string, string>;
+}
+
+/**
+ * Storage object interface
+ */
+export interface StorageObject {
+  key: string;
+  body: ReadableStream | null;
+  bodyUsed: boolean;
+  /**
+   * HTTP `ETag` value to send to clients. Optional because not every
+   * backend (e.g. the in-memory test stub) tracks an etag.
+   */
+  httpEtag?: string;
+  arrayBuffer(): Promise<ArrayBuffer>;
+  text(): Promise<string>;
+  json<T = unknown>(): Promise<T>;
+  httpMetadata?: ObjectMetadata["httpMetadata"];
+  customMetadata?: Record<string, string>;
+}
+
+/**
+ * List objects result
+ */
+export interface ListObjectsResult {
+  objects: Array<{
+    key: string;
+    size: number;
+    uploaded: Date;
+    etag?: string;
+    httpMetadata?: ObjectMetadata["httpMetadata"];
+  }>;
+  truncated: boolean;
+  cursor?: string;
+  delimitedPrefixes?: string[];
+}
+
+/**
+ * Object storage interface - abstracts R2Bucket
+ */
+export interface IObjectStorage {
+  put(
+    key: string,
+    value: ReadableStream | ArrayBuffer | string,
+    options?: {
+      httpMetadata?: ObjectMetadata["httpMetadata"];
+      customMetadata?: Record<string, string>;
+    },
+  ): Promise<void>;
+
+  get(key: string): Promise<StorageObject | null>;
+
+  delete(key: string | string[]): Promise<void>;
+
+  list(options?: {
+    prefix?: string;
+    limit?: number;
+    cursor?: string;
+    delimiter?: string;
+  }): Promise<ListObjectsResult>;
+
+  head(key: string): Promise<ObjectMetadata | null>;
+}
+
+/**
+ * Key-value store interface - abstracts KVNamespace
+ */
+export interface IKeyValueStore {
+  get(key: string, options?: { type?: "text" }): Promise<string | null>;
+  get<T = unknown>(key: string, options: { type: "json" }): Promise<T | null>;
+  get(
+    key: string,
+    options: { type: "arrayBuffer" },
+  ): Promise<ArrayBuffer | null>;
+
+  put(
+    key: string,
+    value: string | ArrayBuffer | ReadableStream,
+    options?: {
+      expirationTtl?: number;
+      expiration?: number;
+      metadata?: Record<string, unknown>;
+    },
+  ): Promise<void>;
+
+  delete(key: string): Promise<void>;
+
+  list(options?: {
+    prefix?: string;
+    limit?: number;
+    cursor?: string;
+  }): Promise<{
+    keys: Array<{ name: string; expiration?: number; metadata?: unknown }>;
+    list_complete: boolean;
+    cursor?: string;
+  }>;
+}
+
+/**
+ * Static assets fetcher interface
+ */
+export interface IStaticAssets {
+  fetch(request: Request): Promise<Response>;
+}
+
+/**
+ * Runtime environment - for non-Cloudflare runtimes
+ */
+export interface RuntimeEnv {
+  db: IDatabase;
+  storage?: IObjectStorage;
+  kv?: IKeyValueStore;
+  assets?: IStaticAssets;
+
+  // Environment variables
+  APP_URL: string;
+  AUTH_PASSWORD_HASH?: string;
+  GOOGLE_CLIENT_ID?: string;
+  GOOGLE_CLIENT_SECRET?: string;
+  X_CLIENT_ID?: string;
+  X_CLIENT_SECRET?: string;
+  OIDC_ISSUER_URL?: string;
+  OIDC_CLIENT_ID?: string;
+  OIDC_CLIENT_SECRET?: string;
+  OAUTH_ISSUER_URL?: string;
+  TAKOSUMI_ACCOUNTS_ISSUER_URL?: string;
+  TAKOSUMI_ACCOUNTS_CLIENT_ID?: string;
+  TAKOSUMI_ACCOUNTS_CLIENT_SECRET?: string;
+  TAKOS_URL?: string;
+  AUTH_MODE?: string;
+}