@terrafirmagreg-team/data 0.1.0 → 1.2.0

package/package.json

@@ -1,27 +1,23 @@
 {
   "name": "@terrafirmagreg-team/data",
-  "version": "0.1.0",
+  "version": "1.2.0",
   "type": "module",
+  "description": "Storage drivers and shared helpers",
+  "license": "LGPL-3.0-only",
   "exports": {
     ".": "./src/lib/index.ts",
-    "./*": [
-      "./src/*.ts",
-      "./src/*.tsx",
-      "./src/*/index.ts",
-      "./src/*/index.tsx",
-      "./src/*/*.ts",
-      "./src/*/*.tsx",
-      "./src/*/*/index.ts",
-      "./src/*/*/index.tsx"
+    "./lib/*": [
+      "./src/lib/*.ts",
+      "./src/lib/*/index.ts"
     ]
   },
   "files": [
-    "src",
-    "styles",
-    "styles.css",
-    "locales"
+    "src"
   ],
   "dependencies": {
+    "fumadb": "0.6.0",
+    "kysely": "^0.29.8",
+    "kysely-d1": "^0.4.0",
     "server-only": "^0.0.1"
   },
   "devDependencies": {

package/src/lib/app-token.ts

@@ -0,0 +1,70 @@
+import { env } from './env';
+import { githubFetch } from './github';
+
+const TOKEN_TTL_MS = 50 * 60 * 1000;
+const cache = new Map<string, { token: Promise<string>; exp: number }>();
+
+function pemToDer(pem: string): ArrayBuffer {
+  const b64 = pem.replace(/\\n/g, '\n').replace(/-----(?:BEGIN|END)[^\n-]*-----|\s/g, '');
+  const bin = Buffer.from(b64, 'base64');
+  return bin.buffer.slice(
+    bin.byteOffset,
+    bin.byteOffset + bin.byteLength,
+  ) as ArrayBuffer;
+}
+
+async function appJwt(): Promise<string> {
+  const appId = env('APP_ID');
+  const pem = env('APP_PRIVATE_KEY');
+  if (!appId || !pem)
+    throw new Error('APP_ID / APP_PRIVATE_KEY are not configured');
+  const now = Math.floor(Date.now() / 1000);
+  const pack = (value: object) =>
+    Buffer.from(JSON.stringify(value)).toString('base64url');
+  const payload = `${pack({ alg: 'RS256', typ: 'JWT' })}.${pack({ iat: now - 60, exp: now + 540, iss: appId })}`;
+  const key = await crypto.subtle.importKey(
+    'pkcs8',
+    pemToDer(pem),
+    { name: 'RSASSA-PKCS1-v1_5', hash: 'SHA-256' },
+    false,
+    ['sign'],
+  );
+  const signature = await crypto.subtle.sign(
+    'RSASSA-PKCS1-v1_5',
+    key,
+    new TextEncoder().encode(payload),
+  );
+  return `${payload}.${Buffer.from(signature).toString('base64url')}`;
+}
+
+async function mintInstallationToken(repo: string): Promise<string> {
+  const jwt = await appJwt();
+  const installation = await githubFetch(`/repos/${repo}/installation`, {
+    token: jwt,
+  });
+  if (!installation.ok)
+    throw new Error(`app installation lookup ${repo}: ${installation.status}`);
+  const { id } = (await installation.json()) as { id: number };
+  const response = await githubFetch(
+    `/app/installations/${id}/access_tokens`,
+    { token: jwt, method: 'POST' },
+  );
+  if (!response.ok)
+    throw new Error(`app installation token ${repo}: ${response.status}`);
+  return ((await response.json()) as { token: string }).token;
+}
+
+export function githubAppToken(repo: string): Promise<string> {
+  const cached = cache.get(repo);
+  if (cached && cached.exp > Date.now()) return cached.token;
+  const entry = {
+    token: mintInstallationToken(repo).catch((err) => {
+      cache.delete(repo);
+      throw err;
+    }),
+    exp: Date.now() + TOKEN_TTL_MS,
+  };
+  cache.set(repo, entry);
+  return entry.token;
+}
+

package/src/lib/async-cache.ts

@@ -0,0 +1,49 @@
+export type AsyncCache<A extends unknown[], V> = ((
+  ...args: A
+) => Promise<V>) & {
+  peek: (...args: A) => V | undefined;
+};
+
+export function createAsyncCache<A extends unknown[], V>(
+  loader: (...args: A) => Promise<V>,
+  keyOf: (...args: A) => string = (...args) => JSON.stringify(args),
+  ttl?: number,
+): AsyncCache<A, V> {
+  const cache = new Map<string, Promise<V>>();
+  const resolved = new Map<string, V>();
+  const expiry = new Map<string, number>();
+  const expired = (key: string) => {
+    const at = expiry.get(key);
+    return at !== undefined && at <= Date.now();
+  };
+  const call = (...args: A) => {
+    const key = keyOf(...args);
+    let pending = cache.get(key);
+    if (pending && expired(key)) {
+      cache.delete(key);
+      resolved.delete(key);
+      expiry.delete(key);
+      pending = undefined;
+    }
+    if (!pending) {
+      pending = loader(...args)
+        .then((value) => {
+          resolved.set(key, value);
+          if (ttl !== undefined) expiry.set(key, Date.now() + ttl);
+          return value;
+        })
+        .catch((err) => {
+          cache.delete(key);
+          throw err;
+        });
+      cache.set(key, pending);
+    }
+    return pending;
+  };
+  call.peek = (...args: A) => {
+    const key = keyOf(...args);
+    return expired(key) ? undefined : resolved.get(key);
+  };
+  return call;
+}
+

package/src/lib/cache-api.ts

@@ -0,0 +1,17 @@
+import 'server-only';
+
+export async function cachedResponse(
+  _req: Request,
+  ttl: number,
+  load: () => Promise<Response>,
+): Promise<Response> {
+  const res = await load();
+  if (!res.ok) return res;
+  const headers = new Headers(res.headers);
+  headers.set(
+    'Cache-Control',
+    `public, s-maxage=${ttl}, stale-while-revalidate=${ttl}`,
+  );
+  return new Response(res.body, { status: res.status, headers });
+}
+

package/src/lib/cookie.ts

@@ -48,3 +48,4 @@ export function readTokenFromCookieHeader(
     return null;
   }
 }
+

package/src/lib/d1.ts

@@ -0,0 +1,22 @@
+export type D1PreparedStatement = {
+  bind(...values: unknown[]): D1PreparedStatement;
+  first<T>(column?: string): Promise<T | null>;
+  run<T>(): Promise<T>;
+  all<T>(): Promise<{
+    results: T[];
+    meta?: { changes?: number; last_row_id?: number };
+  }>;
+};
+
+export type D1Binding = {
+  prepare(query: string): D1PreparedStatement;
+  exec?(query: string): Promise<unknown>;
+};
+
+export function d1Binding(name: string): D1Binding | undefined {
+  const db = (process.env as Record<string, unknown>)[name];
+  return db && typeof (db as D1Binding).prepare === 'function'
+    ? (db as D1Binding)
+    : undefined;
+}
+

package/src/lib/db.ts

@@ -0,0 +1,143 @@
+import 'server-only';
+import { fumadb, type InferFumaDB } from 'fumadb';
+import { kyselyAdapter } from 'fumadb/adapters/kysely';
+import { column, idColumn, schema, table } from 'fumadb/schema';
+import { Kysely, sql } from 'kysely';
+import { D1Dialect } from 'kysely-d1';
+import { d1Binding, type D1Binding, type D1PreparedStatement } from './d1';
+import { env } from './env';
+
+const v1 = schema({
+  version: '1.0.0',
+  tables: {
+    shares: table('shares', {
+      scope: idColumn('scope', 'varchar(255)'),
+      tree: column('tree', 'string'),
+      created: column('created', 'integer'),
+    }),
+    analytics: table('analytics', {
+      key: idColumn('key', 'varchar(255)'),
+      views: column('views', 'integer'),
+    }),
+  },
+});
+
+const DB_NAMESPACE = env('DB_NAME') ?? 'wiki';
+
+export const AppDB = fumadb({ namespace: DB_NAMESPACE, schemas: [v1] });
+
+export type AppDbClient = InferFumaDB<typeof AppDB>;
+export type DataOrm = ReturnType<AppDbClient['orm']>;
+
+type D1RestResult = {
+  results?: Record<string, unknown>[];
+  success?: boolean;
+  meta?: { changes?: number; last_row_id?: number };
+};
+
+function remoteD1({
+  accountId,
+  databaseId,
+  token,
+}: {
+  accountId: string;
+  databaseId: string;
+  token: string;
+}): D1Binding {
+  const call = async (sql: string, params: unknown[]) => {
+    const res = await fetch(
+      `https://api.cloudflare.com/client/v4/accounts/${accountId}/d1/database/${databaseId}/query`,
+      {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${token}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ sql, params }),
+      },
+    );
+    if (!res.ok) throw new Error(`D1 REST ${res.status}: ${await res.text()}`);
+    const body = (await res.json()) as { result?: D1RestResult[] };
+    const first = body.result?.[0];
+    if (!first?.success) throw new Error('D1 query failed');
+    return first;
+  };
+  return {
+    prepare: (sql) => {
+      let bound: unknown[] = [];
+      const statement: D1PreparedStatement = {
+        bind: (...params: unknown[]) => {
+          bound = params;
+          return statement;
+        },
+        all: async <T,>() => {
+          const res = await call(sql, bound);
+          return { results: (res.results ?? []) as T[], meta: res.meta };
+        },
+        first: async <T,>(column?: string) => {
+          const row = (await call(sql, bound)).results?.[0] as
+            | T
+            | undefined;
+          if (row == null || !column) return (row ?? null) as T | null;
+          return (row as Record<string, unknown>)[column] as T;
+        },
+        run: async <T,>() => (await call(sql, bound)) as T,
+      };
+      return statement;
+    },
+    exec: async (sql) => call(sql, []),
+  };
+}
+
+function resolveD1(): D1Binding | undefined {
+  const bound = d1Binding(env('D1_BINDING') ?? 'DB');
+  if (bound) return bound;
+  const accountId = env('CLOUDFLARE_ACCOUNT_ID');
+  const databaseId = env('CLOUDFLARE_D1_DATABASE_ID');
+  const token = env('CLOUDFLARE_API_TOKEN');
+  return accountId && databaseId && token
+    ? remoteD1({ accountId, databaseId, token })
+    : undefined;
+}
+
+const DDL = [
+  'CREATE TABLE IF NOT EXISTS shares (scope TEXT PRIMARY KEY, tree TEXT NOT NULL, created INTEGER NOT NULL)',
+  'CREATE TABLE IF NOT EXISTS analytics (key TEXT PRIMARY KEY, views INTEGER NOT NULL)',
+  `CREATE TABLE IF NOT EXISTS private_${DB_NAMESPACE}_settings (key TEXT PRIMARY KEY, value TEXT NOT NULL)`,
+  `INSERT OR IGNORE INTO private_${DB_NAMESPACE}_settings (key, value) VALUES ('version', '1.0.0')`,
+];
+
+let ready: Promise<AppDbClient | undefined> | undefined;
+let kyselyDb: Kysely<unknown> | undefined;
+
+export function dbKysely(): Kysely<unknown> | undefined {
+  return kyselyDb;
+}
+
+export function dbSql(strings: TemplateStringsArray, ...values: unknown[]) {
+  const db = kyselyDb;
+  return db ? sql(strings, ...values).execute(db) : undefined;
+}
+
+export function dataDb(): Promise<AppDbClient | undefined> {
+  const p = (ready ??= (async () => {
+    const d1 = resolveD1();
+    if (!d1) return undefined;
+    for (const sql of DDL) await d1.exec?.(sql);
+    const db = new Kysely({
+      dialect: new D1Dialect({ database: d1 as never }),
+    });
+    kyselyDb = db;
+    return AppDB.client(kyselyAdapter({ provider: 'sqlite', db }));
+  })());
+  p.catch(() => {
+    if (ready === p) ready = undefined;
+  });
+  return p;
+}
+
+export async function dbOrm(): Promise<DataOrm | undefined> {
+  const client = await dataDb();
+  return client ? client.orm(await client.version()) : undefined;
+}
+

package/src/lib/env.ts

@@ -1,3 +1,3 @@
-
 export const env = (key: string): string | undefined =>
   process.env[key]?.trim() || undefined;
+

package/src/lib/github.ts

@@ -53,3 +53,4 @@ export async function githubGraphql<T>(
   if (!json.data) throw new Error('GitHub GraphQL: empty response');
   return json.data;
 }
+

package/src/lib/index.ts

@@ -1,5 +1,7 @@
 export { env } from './env';
-export { kvBinding, type KvBinding } from './kv';
+export { d1Binding, type D1Binding } from './d1';
+export { dataDb, dbOrm, dbSql, dbKysely, AppDB, type AppDbClient, type DataOrm } from './db';
+export { githubAppToken } from './app-token';
 export { loadJsonFile, saveJsonFile, jsonFileStore } from './json-file';
 export {
   githubFetch,
@@ -13,3 +15,4 @@ export {
   parseCookies,
   readTokenFromCookieHeader,
 } from './cookie';
+

package/src/lib/json-file.ts

@@ -5,7 +5,7 @@ import { dirname } from 'node:path';
 export function loadJsonFile<T>(file: string, fallback: () => T): T {
   try {
     return JSON.parse(
-      readFileSync( file, 'utf8'),
+      readFileSync(/* turbopackIgnore: true */ file, 'utf8'),
     ) as T;
   } catch {
     return fallback();
@@ -13,8 +13,11 @@ export function loadJsonFile<T>(file: string, fallback: () => T): T {
 }
 
 export function saveJsonFile(file: string, data: unknown, space?: number): void {
-  mkdirSync(dirname(file), { recursive: true });
-  writeFileSync(file, JSON.stringify(data, null, space));
+  mkdirSync(/* turbopackIgnore: true */ dirname(file), { recursive: true });
+  writeFileSync(
+    /* turbopackIgnore: true */ file,
+    JSON.stringify(data, null, space),
+  );
 }
 
 export function jsonFileStore<T>(file: string, fallback: () => T, space?: number) {
@@ -29,3 +32,4 @@ export function jsonFileStore<T>(file: string, fallback: () => T, space?: number
   };
   return store;
 }
+

package/src/lib/kv.ts

@@ -1,15 +0,0 @@
-export type KvBinding = {
-  get(key: string): Promise<string | null>;
-  put(
-    key: string,
-    value: string,
-    opts?: { expirationTtl?: number },
-  ): Promise<void>;
-};
-
-export function kvBinding(name: string): KvBinding | undefined {
-  const kv = (process.env as Record<string, unknown>)[name];
-  return kv && typeof (kv as KvBinding).get === 'function'
-    ? (kv as KvBinding)
-    : undefined;
-}