@hasna/logs 0.3.24 → 0.3.25

package/src/lib/cloud-sync.ts

@@ -1,167 +0,0 @@
-import type { Database } from "bun:sqlite"
-import { getDb } from "../db/index.ts"
-import { PG_MIGRATIONS } from "../db/pg-migrations.ts"
-import { PgAdapterAsync } from "./remote-storage.ts"
-
-export const CLOUD_TABLES = [
-  "projects",
-  "pages",
-  "logs",
-  "scan_jobs",
-  "scan_runs",
-  "performance_snapshots",
-  "alert_rules",
-  "issues",
-  "page_auth",
-  "feedback",
-] as const
-
-type Row = Record<string, unknown>
-
-export function getCloudDatabaseUrl(): string | null {
-  return process.env.HASNA_LOGS_CLOUD_DATABASE_URL
-    ?? process.env.LOGS_CLOUD_DATABASE_URL
-    ?? null
-}
-
-export async function getCloudPg(): Promise<PgAdapterAsync> {
-  const url = getCloudDatabaseUrl()
-  if (!url) throw new Error("Missing HASNA_LOGS_CLOUD_DATABASE_URL or LOGS_CLOUD_DATABASE_URL")
-  return new PgAdapterAsync(url)
-}
-
-export async function runCloudMigrations(remote: PgAdapterAsync): Promise<void> {
-  for (const sql of PG_MIGRATIONS) await remote.run(sql)
-}
-
-export async function cloudPush(opts?: { tables?: string[] }): Promise<{ rows: number }> {
-  const remote = await getCloudPg()
-  try {
-    await runCloudMigrations(remote)
-    const db = getDb()
-    let rows = 0
-    for (const table of resolveTables(opts?.tables)) rows += await pushTable(db, remote, table)
-    return { rows }
-  } finally {
-    await remote.close()
-  }
-}
-
-export async function cloudPull(opts?: { tables?: string[] }): Promise<{ rows: number }> {
-  const remote = await getCloudPg()
-  try {
-    await runCloudMigrations(remote)
-    const db = getDb()
-    let rows = 0
-    for (const table of resolveTables(opts?.tables)) rows += await pullTable(remote, db, table)
-    return { rows }
-  } finally {
-    await remote.close()
-  }
-}
-
-export async function cloudSync(opts?: { tables?: string[] }): Promise<{ push: number; pull: number }> {
-  const push = await cloudPush(opts)
-  const pull = await cloudPull(opts)
-  return { push: push.rows, pull: pull.rows }
-}
-
-function resolveTables(tables?: string[]): string[] {
-  if (!tables || tables.length === 0) return [...CLOUD_TABLES]
-  const allowed = new Set<string>(CLOUD_TABLES)
-  const requested = tables.map(table => table.trim()).filter(Boolean)
-  const invalid = requested.filter(table => !allowed.has(table))
-  if (invalid.length > 0) throw new Error(`Unknown logs sync table(s): ${invalid.join(", ")}`)
-  return requested
-}
-
-function quoteIdent(identifier: string): string {
-  return `"${identifier.replace(/"/g, "\"\"")}"`
-}
-
-async function pushTable(db: Database, remote: PgAdapterAsync, table: string): Promise<number> {
-  const rows = db.query(`SELECT * FROM ${quoteIdent(table)}`).all() as Row[]
-  if (rows.length === 0) return 0
-  const columns = await filterRemoteColumns(remote, table, Object.keys(rows[0]!))
-  await upsertPg(remote, table, columns, rows)
-  return rows.length
-}
-
-async function pullTable(remote: PgAdapterAsync, db: Database, table: string): Promise<number> {
-  const rows = await remote.all(`SELECT * FROM ${quoteIdent(table)}`) as Row[]
-  if (rows.length === 0) return 0
-  const columns = filterLocalColumns(db, table, Object.keys(rows[0]!))
-  upsertSqlite(db, table, columns, rows)
-  return rows.length
-}
-
-async function filterRemoteColumns(remote: PgAdapterAsync, table: string, columns: string[]): Promise<string[]> {
-  const rows = await remote.all(`
-    SELECT column_name
-    FROM information_schema.columns
-    WHERE table_schema = 'public' AND table_name = ?
-  `, table) as Array<{ column_name: string }>
-  if (rows.length === 0) return columns
-  const allowed = new Set(rows.map(row => row.column_name))
-  return columns.filter(column => allowed.has(column))
-}
-
-function filterLocalColumns(db: Database, table: string, columns: string[]): string[] {
-  const rows = db.query(`PRAGMA table_info(${quoteIdent(table)})`).all() as Array<{ name: string }>
-  const allowed = new Set(rows.map(row => row.name))
-  return columns.filter(column => allowed.has(column))
-}
-
-async function upsertPg(remote: PgAdapterAsync, table: string, columns: string[], rows: Row[]): Promise<void> {
-  if (columns.length === 0) return
-  const columnList = columns.map(quoteIdent).join(", ")
-  const updateColumns = columns.filter(column => column !== "id")
-  const setClause = updateColumns.length > 0
-    ? updateColumns.map(column => `${quoteIdent(column)} = EXCLUDED.${quoteIdent(column)}`).join(", ")
-    : `${quoteIdent("id")} = EXCLUDED.${quoteIdent("id")}`
-
-  for (const row of rows) {
-    const placeholders = columns.map((_, index) => `$${index + 1}`).join(", ")
-    const params = columns.map(column => coerceForPg(table, column, row[column]))
-    await remote.run(
-      `INSERT INTO ${quoteIdent(table)} (${columnList}) VALUES (${placeholders})
-       ON CONFLICT (${quoteIdent("id")}) DO UPDATE SET ${setClause}`,
-      ...params,
-    )
-  }
-}
-
-function upsertSqlite(db: Database, table: string, columns: string[], rows: Row[]): void {
-  if (columns.length === 0) return
-  const columnList = columns.map(quoteIdent).join(", ")
-  const placeholders = columns.map(() => "?").join(", ")
-  const updateColumns = columns.filter(column => column !== "id")
-  const setClause = updateColumns.length > 0
-    ? updateColumns.map(column => `${quoteIdent(column)} = excluded.${quoteIdent(column)}`).join(", ")
-    : `${quoteIdent("id")} = excluded.${quoteIdent("id")}`
-  const statement = db.prepare(
-    `INSERT INTO ${quoteIdent(table)} (${columnList}) VALUES (${placeholders})
-     ON CONFLICT (${quoteIdent("id")}) DO UPDATE SET ${setClause}`,
-  )
-  const insert = db.transaction((batch: Row[]) => {
-    for (const row of batch) statement.run(...columns.map(column => coerceForSqlite(row[column])))
-  })
-  insert(rows)
-}
-
-function coerceForPg(table: string, column: string, value: unknown): unknown {
-  if (value === undefined) return null
-  if ((table === "scan_jobs" || table === "alert_rules") && column === "enabled") {
-    return Boolean(value)
-  }
-  return value
-}
-
-function coerceForSqlite(value: unknown): string | number | bigint | boolean | null | Uint8Array {
-  if (value === undefined || value === null) return null
-  if (typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") return value
-  if (value instanceof Date) return value.toISOString()
-  if (Buffer.isBuffer(value) || value instanceof Uint8Array) return value
-  if (typeof value === "object") return JSON.stringify(value)
-  return String(value)
-}

package/src/lib/remote-storage.ts

@@ -1,45 +0,0 @@
-import pg from "pg"
-import type { Pool } from "pg"
-
-function translatePlaceholders(sql: string): string {
-  let index = 0
-  return sql.replace(/\?/g, () => `$${++index}`)
-}
-
-function normalizeParams(params: unknown[]): unknown[] {
-  const flat = params.length === 1 && Array.isArray(params[0]) ? params[0] : params
-  return flat.map(value => value === undefined ? null : value)
-}
-
-function sslConfigFor(connectionString: string): { rejectUnauthorized: boolean } | undefined {
-  return connectionString.includes("sslmode=require") || connectionString.includes("ssl=true")
-    ? { rejectUnauthorized: false }
-    : undefined
-}
-
-export class PgAdapterAsync {
-  private readonly pool: Pool
-
-  constructor(connectionString: string) {
-    this.pool = new pg.Pool({ connectionString, ssl: sslConfigFor(connectionString) })
-  }
-
-  async run(sql: string, ...params: unknown[]): Promise<{ changes: number }> {
-    const result = await this.pool.query(translatePlaceholders(sql), normalizeParams(params))
-    return { changes: result.rowCount ?? 0 }
-  }
-
-  async get(sql: string, ...params: unknown[]): Promise<unknown> {
-    const result = await this.pool.query(translatePlaceholders(sql), normalizeParams(params))
-    return result.rows[0] ?? null
-  }
-
-  async all(sql: string, ...params: unknown[]): Promise<unknown[]> {
-    const result = await this.pool.query(translatePlaceholders(sql), normalizeParams(params))
-    return result.rows
-  }
-
-  async close(): Promise<void> {
-    await this.pool.end()
-  }
-}