@hasna/shortlinks 0.1.24 → 0.2.0

package/dist/pg-store.d.ts

@@ -6,9 +6,6 @@ type PgAdapterLike = {
     run(sql: string, ...params: unknown[]): Promise<unknown>;
     close?: () => Promise<void>;
 };
-export interface PgConnectionOptions {
-    ssl?: boolean;
-}
 /**
  * Adapt a vendored storage-kit `TypedQueryClient` (which speaks `$1` positional
  * params) to the `?`-placeholder `PgAdapterLike` the store queries are written
@@ -19,10 +16,14 @@ export declare function createKitPgAdapter(client: TypedQueryClient): PgAdapterL
 export declare class PgShortlinksStore {
     private readonly pg;
     constructor(pg: PgAdapterLike);
-    static fromConnectionString(connectionString: string, options?: PgConnectionOptions): Promise<PgShortlinksStore>;
-    /** Build a store over a vendored storage-kit query client (the serve path). */
+    /**
+     * Build a store over a vendored storage-kit query client. This is the ONLY
+     * constructor: the serve entrypoint opens its pool via `createCloudPoolFromEnv`
+     * (server-side) and hands the client here. There is deliberately no
+     * DSN-from-env / connection-string path so this store can never be misused to
+     * open the raw RDS from a client.
+     */
     static fromQueryClient(client: TypedQueryClient): PgShortlinksStore;
-    static fromEnv(env?: NodeJS.ProcessEnv): Promise<PgShortlinksStore>;
     close(): Promise<void>;
     addDomain(input: AddDomainInput): Promise<Domain>;
     listDomains(): Promise<Domain[]>;
@@ -48,9 +49,4 @@ export declare class PgShortlinksStore {
     private hashIp;
     private generateAvailableSlug;
 }
-export declare function applyPostgresMigrations(connectionString: string, migrations: string[], options?: PgConnectionOptions): Promise<{
-    service: "shortlinks";
-    applied: number[];
-    skipped: number[];
-}>;
 export {};

package/dist/pg-store.js

@@ -32,170 +32,6 @@ var __toESM = (mod, isNodeMode, target) => {
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __require = import.meta.require;
 
-// src/runtime.ts
-var SHORTLINKS_RUNTIME_ENV = {
-  store: "HASNA_SHORTLINKS_STORE",
-  databaseUrl: "HASNA_SHORTLINKS_DATABASE_URL",
-  databaseSsl: "HASNA_SHORTLINKS_DATABASE_SSL"
-};
-var SHORTLINKS_RUNTIME_FALLBACK_ENV = {
-  store: "SHORTLINKS_STORE",
-  databaseUrl: "SHORTLINKS_DATABASE_URL",
-  databaseSsl: "SHORTLINKS_DATABASE_SSL"
-};
-var CANONICAL_SHORTLINKS_POSTGRES_CLUSTER = "hasna-xyz-infra-apps-prod-postgres";
-var CANONICAL_SHORTLINKS_POSTGRES_DATABASE = "shortlinks";
-var CANONICAL_SHORTLINKS_RUNTIME_SECRET_PATH = "hasna/xyz/opensource/shortlinks/prod/postgres";
-function getCanonicalShortlinksPostgresConfig() {
-  return {
-    cluster: CANONICAL_SHORTLINKS_POSTGRES_CLUSTER,
-    database: CANONICAL_SHORTLINKS_POSTGRES_DATABASE,
-    runtimeSecretPath: CANONICAL_SHORTLINKS_RUNTIME_SECRET_PATH,
-    primaryEnv: SHORTLINKS_RUNTIME_ENV.databaseUrl,
-    fallbackEnv: SHORTLINKS_RUNTIME_FALLBACK_ENV.databaseUrl
-  };
-}
-function parseShortlinksStoreMode(value) {
-  const normalized = clean(value)?.toLowerCase();
-  if (!normalized)
-    return "local";
-  if (normalized === "local" || normalized === "postgres")
-    return normalized;
-  if (normalized === "pg")
-    return "postgres";
-  throw new Error(`${SHORTLINKS_RUNTIME_ENV.store} must be local or postgres`);
-}
-function getShortlinksStoreMode(env = process.env) {
-  return parseShortlinksStoreMode(readRuntimeEnv(env, "store").value);
-}
-function getShortlinksDatabaseUrl(env = process.env) {
-  return readRuntimeEnv(env, "databaseUrl").value;
-}
-function getShortlinksDatabaseSsl(env = process.env) {
-  return parseBoolean(readRuntimeEnv(env, "databaseSsl").value, true);
-}
-function getShortlinksRuntimeEnvName(env, key) {
-  const primary = SHORTLINKS_RUNTIME_ENV[key];
-  if (clean(env[primary]))
-    return primary;
-  return SHORTLINKS_RUNTIME_FALLBACK_ENV[key];
-}
-function loadShortlinksRuntimeConfig(env = process.env) {
-  const mode = getShortlinksStoreMode(env);
-  const databaseUrl = getShortlinksDatabaseUrl(env);
-  return {
-    service: "shortlinks",
-    mode,
-    ...databaseUrl ? {
-      database: {
-        provider: "postgres",
-        url: databaseUrl,
-        ssl: getShortlinksDatabaseSsl(env)
-      }
-    } : {}
-  };
-}
-function assertShortlinksPostgresConfig(config) {
-  if (config.mode !== "postgres")
-    return;
-  if (!config.database?.url) {
-    throw new Error(`${SHORTLINKS_RUNTIME_ENV.databaseUrl} is required when ${SHORTLINKS_RUNTIME_ENV.store}=postgres`);
-  }
-}
-function getShortlinksRuntimeStatus(env = process.env) {
-  const issues = [];
-  const warnings = [];
-  let config;
-  try {
-    config = loadShortlinksRuntimeConfig(env);
-  } catch (error) {
-    issues.push(error instanceof Error ? error.message : String(error));
-    config = { service: "shortlinks", mode: "local" };
-  }
-  try {
-    assertShortlinksPostgresConfig(config);
-  } catch (error) {
-    issues.push(error instanceof Error ? error.message : String(error));
-  }
-  if (config.mode === "local" && config.database?.url) {
-    warnings.push(`${SHORTLINKS_RUNTIME_ENV.store}=local ignores configured Postgres database settings`);
-  }
-  return {
-    ok: issues.length === 0,
-    service: "shortlinks",
-    mode: config.mode,
-    local_default: config.mode === "local",
-    postgres_enabled: config.mode === "postgres",
-    database: {
-      configured: Boolean(config.database?.url),
-      provider: config.database?.provider ?? null,
-      redacted_url: redactDatabaseUrl(config.database?.url),
-      ssl: config.database?.ssl ?? null
-    },
-    env: runtimeEnvStatus(env),
-    canonical: getCanonicalShortlinksPostgresConfig(),
-    issues,
-    warnings,
-    no_network: true
-  };
-}
-function redactDatabaseUrl(value) {
-  if (!value)
-    return null;
-  try {
-    const url = new URL(value);
-    if (url.username)
-      url.username = "***";
-    if (url.password)
-      url.password = "***";
-    for (const key of Array.from(url.searchParams.keys())) {
-      if (isSensitiveQueryKey(key))
-        url.searchParams.set(key, "***");
-    }
-    return url.toString();
-  } catch {
-    return "(redacted)";
-  }
-}
-function runtimeEnvStatus(env) {
-  return Object.fromEntries(Object.entries(SHORTLINKS_RUNTIME_ENV).map(([key, name]) => {
-    const activeName = getShortlinksRuntimeEnvName(env, key);
-    return [
-      key,
-      {
-        name,
-        active_name: activeName,
-        configured: Boolean(clean(env[activeName]))
-      }
-    ];
-  }));
-}
-function readRuntimeEnv(env, key) {
-  const primary = SHORTLINKS_RUNTIME_ENV[key];
-  const primaryValue = clean(env[primary]);
-  if (primaryValue)
-    return { name: primary, value: primaryValue };
-  const fallback = SHORTLINKS_RUNTIME_FALLBACK_ENV[key];
-  return { name: fallback, value: clean(env[fallback]) };
-}
-function parseBoolean(value, fallback) {
-  const normalized = clean(value)?.toLowerCase();
-  if (!normalized)
-    return fallback;
-  if (["1", "true", "yes", "on"].includes(normalized))
-    return true;
-  if (["0", "false", "no", "off"].includes(normalized))
-    return false;
-  throw new Error(`${SHORTLINKS_RUNTIME_ENV.databaseSsl} must be true or false`);
-}
-function isSensitiveQueryKey(key) {
-  return /(?:^|[_-])(pass(?:word)?|pwd|secret|token|credential|auth|api[_-]?key|access[_-]?key)(?:$|[_-])/i.test(key);
-}
-function clean(value) {
-  const trimmed = value?.trim();
-  return trimmed ? trimmed : undefined;
-}
-
 // src/pg-store.ts
 import { createHash } from "crypto";
 
@@ -497,47 +333,10 @@ function parseJsonObject(value) {
     return {};
   }
 }
-async function loadPgPool() {
-  const importer = new Function("specifier", "return import(specifier)");
-  const module = await importer("pg");
-  return module.Pool;
-}
 function toPostgresSql(sql) {
   let index = 0;
   return sql.replace(/\?/g, () => `$${++index}`);
 }
-function createPgPoolConfig(connectionString, options = {}) {
-  const ssl = options.ssl ?? true;
-  return {
-    connectionString,
-    ...ssl ? { ssl: { rejectUnauthorized: true } } : { ssl: false }
-  };
-}
-
-class PgPoolAdapter {
-  pool;
-  constructor(pool) {
-    this.pool = pool;
-  }
-  static async create(connectionString, options = {}) {
-    const Pool = await loadPgPool();
-    return new PgPoolAdapter(new Pool(createPgPoolConfig(connectionString, options)));
-  }
-  async get(sql, ...params) {
-    const result = await this.pool.query(toPostgresSql(sql), params);
-    return result.rows[0] ?? null;
-  }
-  async all(sql, ...params) {
-    const result = await this.pool.query(toPostgresSql(sql), params);
-    return result.rows;
-  }
-  async run(sql, ...params) {
-    return this.pool.query(toPostgresSql(sql), params);
-  }
-  async close() {
-    await this.pool.end();
-  }
-}
 function toIsoString(value) {
   if (value instanceof Date)
     return value.toISOString();
@@ -619,19 +418,9 @@ class PgShortlinksStore {
   constructor(pg) {
     this.pg = pg;
   }
-  static async fromConnectionString(connectionString, options = {}) {
-    return new PgShortlinksStore(await PgPoolAdapter.create(connectionString, options));
-  }
   static fromQueryClient(client) {
     return new PgShortlinksStore(createKitPgAdapter(client));
   }
-  static async fromEnv(env = process.env) {
-    const connectionString = getShortlinksDatabaseUrl(env);
-    if (!connectionString) {
-      throw new Error("HASNA_SHORTLINKS_DATABASE_URL is required when shortlinks uses the postgres store");
-    }
-    return PgShortlinksStore.fromConnectionString(connectionString, { ssl: getShortlinksDatabaseSsl(env) });
-  }
   async close() {
     await this.pg.close?.();
   }
@@ -860,54 +649,7 @@ class PgShortlinksStore {
     throw new Error("Could not generate an unused slug after 32 attempts.");
   }
 }
-async function applyPostgresMigrations(connectionString, migrations, options = {}) {
-  const Pool = await loadPgPool();
-  const pool = new Pool(createPgPoolConfig(connectionString, options));
-  const client = await pool.connect();
-  const run = (sql, ...params) => client.query(toPostgresSql(sql), params);
-  const get = async (sql, ...params) => {
-    const result = await run(sql, ...params);
-    return result.rows[0] ?? null;
-  };
-  const applied = [];
-  const skipped = [];
-  try {
-    await run("BEGIN");
-    await run(`
-      SELECT pg_advisory_xact_lock(hashtext(?))
-    `, "shortlinks:migrations");
-    await run(`
-      CREATE TABLE IF NOT EXISTS _shortlinks_migrations (
-        id INTEGER PRIMARY KEY,
-        service TEXT NOT NULL DEFAULT 'shortlinks',
-        applied_at TIMESTAMPTZ NOT NULL DEFAULT now()
-      )
-    `);
-    for (let i = 0;i < migrations.length; i += 1) {
-      const id = i + 1;
-      const existing = await get("SELECT id FROM _shortlinks_migrations WHERE id = ? LIMIT 1", id);
-      if (existing) {
-        skipped.push(id);
-        continue;
-      }
-      await run(migrations[i]);
-      await run("INSERT INTO _shortlinks_migrations (id, service, applied_at) VALUES (?, ?, now())", id, "shortlinks");
-      applied.push(id);
-    }
-    await run("COMMIT");
-    return { service: "shortlinks", applied, skipped };
-  } catch (error) {
-    try {
-      await run("ROLLBACK");
-    } catch {}
-    throw error;
-  } finally {
-    client.release();
-    await pool.end();
-  }
-}
 export {
   createKitPgAdapter,
-  applyPostgresMigrations,
   PgShortlinksStore
 };