@terrafirmagreg-team/data 0.0.0-stage → 0.1.0

package/package.json

@@ -1,6 +1,38 @@
 {
   "name": "@terrafirmagreg-team/data",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "type": "module",
+  "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"
+    ]
+  },
+  "files": [
+    "src",
+    "styles",
+    "styles.css",
+    "locales"
+  ],
+  "dependencies": {
+    "server-only": "^0.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^26.6.5"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TerraFirmaGreg-Team/Web-Foundation.git",
+    "directory": "packages/data"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
 }

package/src/lib/cookie.ts

@@ -0,0 +1,50 @@
+import 'server-only';
+import { createCipheriv, createDecipheriv, createHash, randomBytes } from 'node:crypto';
+
+const key = (secret: string) => createHash('sha256').update(secret).digest();
+
+export function encrypt(plaintext: string, secret: string): string {
+  const iv = randomBytes(12);
+  const cipher = createCipheriv('aes-256-gcm', key(secret), iv);
+  const enc = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final()]);
+  return Buffer.concat([iv, cipher.getAuthTag(), enc]).toString('base64url');
+}
+
+export function decrypt(payload: string, secret: string): string {
+  const buf = Buffer.from(payload, 'base64url');
+  const decipher = createDecipheriv('aes-256-gcm', key(secret), buf.subarray(0, 12));
+  decipher.setAuthTag(buf.subarray(12, 28));
+  return Buffer.concat([decipher.update(buf.subarray(28)), decipher.final()]).toString('utf8');
+}
+
+export function parseCookies(header: string | undefined | null): Record<string, string> {
+  const out: Record<string, string> = {};
+  if (!header) return out;
+  for (const part of header.split(';')) {
+    const idx = part.indexOf('=');
+    if (idx === -1) continue;
+    const k = part.slice(0, idx).trim();
+    const v = part.slice(idx + 1).trim();
+    if (!k) continue;
+    try {
+      out[k] = decodeURIComponent(v);
+    } catch {
+
+    }
+  }
+  return out;
+}
+
+export function readTokenFromCookieHeader(
+  header: string | undefined | null,
+  cookieName: string,
+  secret: string,
+): string | null {
+  const raw = parseCookies(header)[cookieName];
+  if (!raw) return null;
+  try {
+    return decrypt(raw, secret);
+  } catch {
+    return null;
+  }
+}

package/src/lib/env.ts

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

package/src/lib/github.ts

@@ -0,0 +1,55 @@
+const GITHUB_API = 'https://api.github.com';
+
+export interface GithubFetchOptions {
+  token?: string;
+
+  timeoutMs?: number;
+  method?: string;
+  body?: BodyInit | null;
+  headers?: Record<string, string>;
+}
+
+export function githubHeaders(token?: string): Record<string, string> {
+  return {
+    Accept: 'application/vnd.github+json',
+    'X-GitHub-Api-Version': '2022-11-28',
+    ...(token ? { Authorization: `Bearer ${token}` } : {}),
+  };
+}
+
+export function githubFetch(
+  path: `/${string}`,
+  options: GithubFetchOptions = {},
+): Promise<Response> {
+  return fetch(`${GITHUB_API}${path}`, {
+    method: options.method,
+    body: options.body,
+    redirect: 'error',
+    headers: { ...githubHeaders(options.token), ...options.headers },
+    signal: options.timeoutMs ? AbortSignal.timeout(options.timeoutMs) : undefined,
+  });
+}
+
+export async function githubGraphql<T>(
+  query: string,
+  variables: Record<string, unknown>,
+  options: Pick<GithubFetchOptions, 'token'> & { userAgent?: string },
+): Promise<T> {
+  const res = await fetch(`${GITHUB_API}/graphql`, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${options.token}`,
+      'Content-Type': 'application/json',
+      'User-Agent': options.userAgent ?? '@terrafirmagreg-team/data',
+    },
+    body: JSON.stringify({ query, variables }),
+    cache: 'no-store',
+  });
+  if (!res.ok) throw new Error(`GitHub GraphQL ${res.status}: ${await res.text()}`);
+  const json = (await res.json()) as { data?: T; errors?: { message: string }[] };
+  if (json.errors?.length) {
+    throw new Error(`GitHub GraphQL: ${json.errors.map((e) => e.message).join('; ')}`);
+  }
+  if (!json.data) throw new Error('GitHub GraphQL: empty response');
+  return json.data;
+}

package/src/lib/index.ts

@@ -0,0 +1,15 @@
+export { env } from './env';
+export { kvBinding, type KvBinding } from './kv';
+export { loadJsonFile, saveJsonFile, jsonFileStore } from './json-file';
+export {
+  githubFetch,
+  githubGraphql,
+  githubHeaders,
+  type GithubFetchOptions,
+} from './github';
+export {
+  encrypt,
+  decrypt,
+  parseCookies,
+  readTokenFromCookieHeader,
+} from './cookie';

package/src/lib/json-file.ts

@@ -0,0 +1,31 @@
+import 'server-only';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+export function loadJsonFile<T>(file: string, fallback: () => T): T {
+  try {
+    return JSON.parse(
+      readFileSync( file, 'utf8'),
+    ) as T;
+  } catch {
+    return fallback();
+  }
+}
+
+export function saveJsonFile(file: string, data: unknown, space?: number): void {
+  mkdirSync(dirname(file), { recursive: true });
+  writeFileSync(file, JSON.stringify(data, null, space));
+}
+
+export function jsonFileStore<T>(file: string, fallback: () => T, space?: number) {
+  let cached: T | undefined;
+  const store = {
+    get data(): T {
+      return (cached ??= loadJsonFile(file, fallback));
+    },
+    save(): void {
+      saveJsonFile(file, store.data, space);
+    },
+  };
+  return store;
+}

package/src/lib/kv.ts

@@ -0,0 +1,15 @@
+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;
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.