Open Beta

[urania-dev]

A quick update on Snapp as it approaches the v1 release.

The codebase has been fully refactored for this version: cleaner multi-tenant layout, a simpler and stricter permission model, a revised metrics pipeline, and a more coherent API surface (dropping the previous ZenStack-heavy setup, which was unnecessary for a project of this scope). The UI was rebuilt with a cleaner navigation structure, faster tables, and more consistent theming.

Most core features seem stable at this point: link creation, advanced routing, UTM tracking, per-organization domains, teams, roles, tags, safety checks, and the full analytics dashboard. The API layer is consolidated and typed end-to-end, and the system behaves more predictably under multi-tenant load.

To help validate the release, there’s an open beta at:

https://beta.snapp.li/

Anyone can sign up. The environment is intentionally self-wiping: data is public, temporary, and cleared regularly as the stack is rebuilt. It’s a demo sandbox, not a private workspace.

If you want to explore the upcoming v1, this is the right moment. Create organizations, add members, build link catalogs, apply tags, test redirects, stress the dashboard, inspect metrics, and check how the API behaves under odd or borderline inputs. Every interaction helps uncover issues before the final release.

Feedback, bug reports, and unexpected behaviors are welcome while the beta remains open.

If you want to test admin-level features, just subscribe and ask. I’ll grant temporary admin privileges between wipe cycles.

[urania-dev]

One note about the beta environment: it is not self-hostable yet. The version running at beta.snapp.li is my own hosted instance for testing and validation. Self-hosting support will be available once the v1 release is finalized and the deployment workflow is stable enough to publish. For now, the beta should be treated purely as a temporary, hosted demo.

[urania-dev]

Update 16/12/2025

I uploaded as set as default branch the new version, some parts are still missing (i.ex. I18N) but i'm working on it.

I just wanted to show you the entity of the whole refactor, and prove that i'm working on it :D

[archraziel88]

update 20/12/2025

I locked myself out of urania account, as i broke the phone with the 2fa and maybe after christmas i can take it to repair.

meanwhile, i will not be able to manage this github repository as i would, we'll se what will happen.

The app is now in open beta selfhostable, i also created some documentation to help you test it :)

any feedback or open issue is welcome! 🚀

[archraziel88]

Migration script (ai generated but tested and working, also fix some typos in metrics)

#!/usr/bin/env bash

# Uncomment for bash debugging (shows each command executed)
# set -x

# CONFIG --------------------------
DB_HOST="localhost"
DB_PORT="5432"
DB_USER="user"
DB_PASS="database-password"
DB_NAME="snapp" # "local" "what the db is called"

BACKUP_DIR="./db_downloads"
TIMESTAMP=$(date +"%Y-%m-%d_%H-%M-%S")
OUTPUT_FILE="${BACKUP_DIR}/snapp_data_${TIMESTAMP}.sql"
# --------------------------------

echo "📁 Creating output directory at: $BACKUP_DIR"
mkdir -p "$BACKUP_DIR"

echo "🔧 Testing connection to PostgreSQL at $DB_HOST:$DB_PORT..."
PGPASSWORD="$DB_PASS" psql \
    -h "$DB_HOST" \
    -p "$DB_PORT" \
    -U "$DB_USER" \
    -d "$DB_NAME" \
    -c "SELECT NOW();" 2>&1

if [ $? -ne 0 ]; then
    echo "❌ ERROR: Failed to connect to the database."
    exit 1
fi

echo ""
echo "🚀 Starting verbose pg_dump for database '$DB_NAME'..."
echo "📤 Output file: $OUTPUT_FILE"
echo ""

PGPASSWORD="$DB_PASS" pg_dump \
    -h "$DB_HOST" \
    -p "$DB_PORT" \
    -U "$DB_USER" \
    -d "$DB_NAME" \
    --data-only \
    --column-inserts \
    -v \
    > "$OUTPUT_FILE" 2> "${OUTPUT_FILE}.log"

DUMP_STATUS=$?

echo ""
if [ $DUMP_STATUS -ne 0 ]; then
    echo "❌ ERROR: pg_dump failed. See log file:"
    echo "   → ${OUTPUT_FILE}.log"
    exit 1
fi

echo "✅ Data download complete!"
echo "📄 SQL file saved: $OUTPUT_FILE"
echo "📝 Verbose log saved: ${OUTPUT_FILE}.log"
echo "\n"

Env for Typescript (Related to the new DB)

LEGACY_ORG_ORIGIN="https://<previous-origin>"
DATABASE_URL="postgres://root:pass@db:5432/local"

Typescript Migration file

// migrate-legacy.ts
// Usage: 
// 1) bun install postgres drizzle-kit@beta drizzle-orm@beta
// 2) bun ./migrate-legacy.ts ./bkp.sql

import { randomUUID } from "node:crypto";
import postgres from "postgres";
import { drizzle } from "drizzle-orm/postgres-js";
import { eq } from "drizzle-orm";

import {
  user,
  account,
  member,
  organization,
  url,
  metric,
  tag as tagTable,
  urlToTag,
} from "./schema";
import * as schema from "./schema";
import { relations } from "./schema";

type OldUser = {
  id: string;
  email: string;
  username: string;
  password: string;
  notes: string | null;
  role: string | null;
  createdAt: string;
  updatedAt: string;
  verified: boolean;
};

type OldSnapp = {
  id: string;
  shortcode: string;
  originalUrl: string;
  createdAt: string;
  expiresAt: string | null;
  disabled: boolean;
  userId: string;
  groupId: string | null;
  utmParams: string | null;
  secret: string | null;
  maxUsages: number;
  hit: number;
  used: number;
  notes: string | null;
};

type OldTag = {
  name: string;
  slug: string;
  notes: string | null;
};

type OldUsage = {
  id: number;
  timestamp: string;
  snappId: string;
  ownerId: string;
  language: string | null;
  userAgent: string | null;
  referrer: string | null;
  device: string | null;
  country: string | null;
  region: string | null;
  city: string | null;
  os: string | null;
  browser: string | null;
  cpu: string | null;
};

type OldSnapptag = {
  snappId: string;
  tagSlugOrId: string;
};

type SqlPrimitive = string | number | boolean | null;

type InsertChunk = {
  columns: string[];
  values: SqlPrimitive[][];
};

function requireEnv(name: string): string {
  const v = process.env[name];
  if (!v) {
    console.error(`❌ Missing env var ${name}`);
    process.exit(1);
  }
  return v;
}

const dumpPath = process.argv[2];
if (!dumpPath) {
  console.error("❌ Usage: bun run migrate-legacy.ts ./bkp.sql");
  process.exit(1);
}
export const slugify = (text: string = '',delimiter='-') => {
	return text
		.normalize('NFKD')
		.replace(/[\u0300-\u036f]/g, '')
		.replace(' ', delimiter)
		.toLowerCase()
		.replace(/[^a-z0-9 -]/g, '')
		.replace(/\s+/g, delimiter)
		.replace(/-+/g, delimiter);
};

const DATABASE_URL = requireEnv("DATABASE_URL");
const LEGACY_ORG_ORIGIN = requireEnv("LEGACY_ORG_ORIGIN");
const LEGACY_ORG_ID = slugify(LEGACY_ORG_ORIGIN)
const LEGACY_ORG_SLUG = slugify(LEGACY_ORG_ORIGIN)

const client = postgres(DATABASE_URL);
export const db = drizzle({
  client,
  relations,
  schema,
});

const CHUNK_SIZE = 500;

function logStep(msg: string): void {
  console.log(`\n🟦 ${msg}`);
}

function logInfo(msg: string): void {
  console.log(`   ⮡ ${msg}`);
}

// ---- simple line-based INSERT parser --------------------------------------

function convertToken(token: string): SqlPrimitive {
  if (token.toUpperCase() === "NULL") return null;
  if (/^(true|false)$/i.test(token)) return token.toLowerCase() === "true";
  if (/^-?\d+$/.test(token)) return Number(token);
  return token.replace(/^'(.*)'$/, "$1");
}

function parseLineInsert(line: string, table: string): InsertChunk | null {
  const prefix = `INSERT INTO public.${table}`;
  if (!line.startsWith(prefix)) return null;

  const colMatch = line.match(/\(([^)]+)\)/);
  if (!colMatch) return null;

  const columns = colMatch[1].split(",").map((c) => c.trim().replace(/"/g, ""));

  const valuesMatch = line.match(/VALUES\s*\((.*)\)\s*;$/);
  if (!valuesMatch) return null;

  const raw = valuesMatch[1];
  const values: SqlPrimitive[] = [];
  let token = "";
  let inString = false;

  for (let i = 0; i < raw.length; i += 1) {
    const ch = raw[i];

    if (inString) {
      if (ch === "'" && raw[i + 1] === "'") {
        token += "'";
        i += 1;
      } else if (ch === "'") {
        inString = false;
      } else {
        token += ch;
      }
    } else {
      if (ch === "'") {
        inString = true;
      } else if (ch === ",") {
        values.push(convertToken(token.trim()));
        token = "";
        continue;
      } else {
        token += ch;
      }
    }
  }

  if (token.trim().length > 0) {
    values.push(convertToken(token.trim()));
  }

  return { columns, values: [values] };
}

function extractInsertsSafe(dump: string, table: string): InsertChunk[] {
  const lines = dump.split("\n");
  const results: InsertChunk[] = [];

  for (const line of lines) {
    const parsed = parseLineInsert(line.trim(), table);
    if (parsed) results.push(parsed);
  }

  return results;
}

// --- UTM parser ------------------------------------------------------------

type ParsedUtm = Record<
  string,
  {
    key: string;
    value: string;
    name: string;
  }
>;

function parseLegacyUtm(utmParams: string | null): ParsedUtm {
  if (!utmParams) return {};
  const trimmed = utmParams.trim();
  if (trimmed === "" || trimmed === "[]") return {};

  try {
    const outer = JSON.parse(trimmed) as string[];
    const result: ParsedUtm = {};

    for (const entry of outer) {
      try {
        const [key, value, name] = JSON.parse(entry) as [string, string, string];
        result[key] = { key, value, name };
      } catch {
        // ignore broken entry
      }
    }
    return result;
  } catch {
    return {};
  }
}

// --- helpers ---------------------------------------------------------------

function safeDate(input: unknown): Date {
  if (!input) return new Date();
  if (input instanceof Date && !Number.isNaN(input.getTime())) return input;
  if (typeof input === "string") {
    const d = new Date(input);
    if (!Number.isNaN(d.getTime())) return d;
  }
  return new Date();
}

function safeEmail(email: unknown, userId: string): string {
  if (typeof email === "string" && email.trim().length > 0) return email.trim();
  return `${userId}@legacy.local`;
}

async function findExistingUserByEmailOrId(u: OldUser) {
  if (u.email && typeof u.email === "string" && u.email.trim().length > 0) {
    const existingByEmail = await db
      .select()
      .from(user)
      .where(eq(user.email, u.email.trim()))
      .limit(1);

    if (existingByEmail.length > 0) return existingByEmail[0];
  }

  if (u.id && typeof u.id === "string" && u.id.trim().length > 0) {
    const byId = await db
      .select()
      .from(user)
      .where(eq(user.id, u.id.trim()))
      .limit(1);

    if (byId.length > 0) return byId[0];
  }

  return null;
}

// --- MAIN ------------------------------------------------------------------

async function main(): Promise<void> {
  logStep(`Reading SQL dump from: ${dumpPath}`);
  const file = Bun.file(dumpPath);
  const dumpText = await file.text();
  logInfo(`Dump size: ${(dumpText.length / (1024 * 1024)).toFixed(1)} MB`);

  // ---- users --------------------------------------------------------------
  logStep("Parsing old users...");
  const userInserts = extractInsertsSafe(dumpText, "users");
  const oldUsers: OldUser[] = [];

  for (const ins of userInserts) {
    const idx = ins.columns;
    for (const row of ins.values) {
      const col = (name: string): SqlPrimitive =>
        row[idx.indexOf(name)] ?? null;

      oldUsers.push({
        id: String(col("id")),
        email: col("email") as string,
        username: col("username") as string,
        password: (col("password") ?? "") as string,
        notes: (col("notes") as string) ?? null,
        role: (col("role") as string) ?? null,
        createdAt: (col("createdAt") as string) ?? "",
        updatedAt: (col("updatedAt") as string) ?? "",
        verified: Boolean(col("verified")),
      });
    }
  }
  logInfo(`Found ${oldUsers.length} users`);

  // ---- snapps -------------------------------------------------------------
  logStep("Parsing old snapps (short URLs)...");
  const snappInserts = extractInsertsSafe(dumpText, "snapps");
  const oldSnapps: OldSnapp[] = [];

  for (const ins of snappInserts) {
    const idx = ins.columns;
    for (const row of ins.values) {
      const col = (name: string): SqlPrimitive =>
        row[idx.indexOf(name)] ?? null;

      oldSnapps.push({
        id: String(col("id")),
        shortcode: (col("shortcode") as string) ?? "",
        originalUrl: (col("originalUrl") as string) ?? "",
        createdAt: (col("createdAt") as string) ?? "",
        expiresAt: (col("expiresAt") as string) ?? null,
        disabled: Boolean(col("disabled")),
        userId: (col("userId") as string) ?? "",
        groupId: (col("groupId") as string) ?? null,
        utmParams: (col("utmParams") as string) ?? null,
        secret: (col("secret") as string) ?? null,
        maxUsages: Number(col("maxUsages") ?? -1),
        hit: Number(col("hit") ?? 0),
        used: Number(col("used") ?? 0),
        notes: (col("notes") as string) ?? null,
      });
    }
  }
  logInfo(`Found ${oldSnapps.length} snapps`);

  // ---- tags ---------------------------------------------------------------
  logStep("Parsing old tags...");
  const tagInserts = extractInsertsSafe(dumpText, "tags");
  const oldTags: OldTag[] = [];

  for (const ins of tagInserts) {
    const idx = ins.columns;
    for (const row of ins.values) {
      const col = (name: string): SqlPrimitive =>
        row[idx.indexOf(name)] ?? null;

      oldTags.push({
        name: (col("name") as string) ?? "",
        slug: (col("slug") as string) ?? "",
        notes: (col("notes") as string) ?? null,
      });
    }
  }
  logInfo(`Found ${oldTags.length} tags`);

  // ---- usages -------------------------------------------------------------
  logStep("Parsing old usages (metrics)...");
  const usageInserts = extractInsertsSafe(dumpText, "usages");
  const oldUsages: OldUsage[] = [];

  for (const ins of usageInserts) {
    const idx = ins.columns;
    for (const row of ins.values) {
      const col = (name: string): SqlPrimitive =>
        row[idx.indexOf(name)] ?? null;

      oldUsages.push({
        id: Number(col("id") ?? 0),
        timestamp: (col("timestamp") as string) ?? "",
        snappId: (col("snappId") as string) ?? "",
        ownerId: (col("ownerId") as string) ?? "",
        language: (col("language") as string) ?? null,
        userAgent: (col("userAgent") as string) ?? null,
        referrer: (col("referrer") as string) ?? null,
        device: (col("device") as string) ?? null,
        country: (col("country") as string) ?? null,
        region: (col("region") as string) ?? null,
        city: (col("city") as string) ?? null,
        os: (col("os") as string) ?? null,
        browser: (col("browser") as string) ?? null,
        cpu: (col("cpu") as string) ?? null,
      });
    }
  }
  logInfo(`Found ${oldUsages.length} usage rows`);

  // ---- snapptags ----------------------------------------------------------
  logStep("Parsing old _snapptags (if any)...");
  const snapptagsInserts = extractInsertsSafe(dumpText, "_snapptags");
  const oldSnapptags: OldSnapptag[] = [];

  for (const ins of snapptagsInserts) {
    const idx = ins.columns;
    for (const row of ins.values) {
      const snappId =
        (row[idx.indexOf("snappId")] as string | undefined) ??
        (row[0] as string);
      const tagSlugOrId =
        (row[idx.indexOf("tagId")] as string | undefined) ??
        (row[1] as string);

      oldSnapptags.push({
        snappId,
        tagSlugOrId: String(tagSlugOrId),
      });
    }
  }
  logInfo(`Found ${oldSnapptags.length} snapptag relations`);

  // ---- DB -----------------------------------------------------------------
  logStep("Connecting to new database...");
  await client`select 1`;
  logInfo("DB connection OK");

  logStep("Ensuring legacy organization exists...");
  await db
    .insert(organization)
    .values({
      id: LEGACY_ORG_ID,
      name: "Legacy import",
      slug: LEGACY_ORG_SLUG,
      createdAt: safeDate(new Date().toISOString()),
      logo: null,
      metadata: JSON.stringify({ origin: LEGACY_ORG_ORIGIN }),
    })
    .onConflictDoNothing({ target: organization.id });
  logInfo("Legacy organization inserted (or already existed)");

  // ---- users migration + legacy→new id map --------------------------------
  logStep("Migrating users -> user + account + member...");

  const migratedUsers: { id: string; email: string }[] = [];
  const legacyToNewUserId = new Map<string, string>();

  for (const u of oldUsers) {
    const legacyId =
      u.id && typeof u.id === "string" ? u.id.trim() : "";

    const existing = await findExistingUserByEmailOrId(u);

    if (existing) {
      logInfo(`User exists → reusing: ${existing.email}`);
      if (legacyId) {
        legacyToNewUserId.set(legacyId, existing.id);
      }
      migratedUsers.push({ id: existing.id, email: existing.email });
      continue;
    }

    const userId = legacyId && legacyId.length > 0 ? legacyId : randomUUID();

    let newEmail = safeEmail(u.email, userId);
    if (
      newEmail.startsWith("$2a$") ||
      newEmail.includes(" ") ||
      newEmail === "null@legacy.local"
    ) {
      newEmail = `${userId}@legacy.local`;
    }

    await db.transaction(async (tx) => {
      await tx
        .insert(user)
        .values({
          id: userId,
          email: newEmail,
          username: u.username || userId,
          displayUsername: u.username || userId,
          name: u.username || u.email || "Legacy User",
          notes: u.notes ?? "",
          role: u.role ?? null,
          emailVerified: u.verified ?? false,
          createdAt: safeDate(u.createdAt),
          updatedAt: safeDate(u.updatedAt),
          banned: false,
          banExpires: null,
          banReason: null,
          twoFactorEnabled: false,
          image: null,
        })
        .onConflictDoNothing({ target: user.id });

      await tx
        .insert(account)
        .values({
          id: `acc_${userId}`,
          userId,
          providerId: "legacy",
          accountId: newEmail,
          password: u.password,
          createdAt: safeDate(u.createdAt),
          updatedAt: safeDate(u.updatedAt),
          accessToken: null,
          accessTokenExpiresAt: null,
          idToken: null,
          refreshToken: null,
          refreshTokenExpiresAt: null,
          scope: null,
        })
        .onConflictDoNothing({ target: account.id });

      await tx
        .insert(member)
        .values({
          id: `mem_${userId}`,
          organizationId: LEGACY_ORG_ID,
          userId,
          role:
            u.role && ["admin"].includes(u.role.toLowerCase())
              ? "admin"
              : u.role && ["root"].includes(u.role.toLowerCase())
              ? "owner"
              : "member",
          createdAt: safeDate(u.createdAt),
        })
        .onConflictDoNothing({ target: member.id });
    });

    if (legacyId) {
      legacyToNewUserId.set(legacyId, userId);
    }

    logInfo(`Created new user: ${newEmail}`);

    migratedUsers.push({
      id: userId,
      email: newEmail,
    });
  }

  logStep("Users migrated");

  // ---- tags ---------------------------------------------------------------
  logStep("Migrating tags -> tag...");
  const tagIdMap = new Map<string, string>();

  const tagRows = oldTags.map((t) => {
    const id = t.slug && t.slug.length > 0 ? t.slug : randomUUID();
    tagIdMap.set(t.slug || t.name, id);
    return { id, tag: t.name };
  });

  for (let i = 0; i < tagRows.length; i += CHUNK_SIZE) {
    const chunk = tagRows.slice(i, i + CHUNK_SIZE);
    logInfo(`Inserting tags ${i + 1}–${i + chunk.length} / ${tagRows.length}`);
    await db
      .insert(tagTable)
      .values(chunk)
      .onConflictDoNothing({ target: tagTable.id });
  }

  logStep("Tags migrated");

  // ---- urls (snapps) ------------------------------------------------------
  logStep("Migrating snapps -> url...");

  const legacyUtmBySnappId = new Map<string, ParsedUtm>();
  for (const s of oldSnapps) {
    legacyUtmBySnappId.set(String(s.id), parseLegacyUtm(s.utmParams));
  }

  const urlRows = oldSnapps.map((s) => {
    const mappedUserId =
      (s.userId && legacyToNewUserId.get(String(s.userId))) ?? s.userId;

    return {
      id: s.id,
      shortcode: s.shortcode,
      originalUrl: s.originalUrl,
      createdAt: safeDate(s.createdAt),
      updatedAt: safeDate(s.createdAt),
      expiresAt: s.expiresAt ? safeDate(s.expiresAt) : null,
      active: !s.disabled,
      limit: s.maxUsages ?? -1,
      hit: s.hit ?? 0,
      notes: s.notes,
      secret: s.secret,
      userId: mappedUserId,
      organizationId: LEGACY_ORG_ID,
      status: "clean",
      utm: legacyUtmBySnappId.get(String(s.id)) ?? {},
    };
  });

  for (let i = 0; i < urlRows.length; i += CHUNK_SIZE) {
    const chunk = urlRows.slice(i, i + CHUNK_SIZE);
    logInfo(`Inserting urls ${i + 1}–${i + chunk.length} / ${urlRows.length}`);
    await db.insert(url).values(chunk).onConflictDoNothing({ target: url.id });
  }

  logStep("URLs migrated");

  // ---- url_tag (snapptags) ------------------------------------------------
  if (oldSnapptags.length > 0) {
    logStep("Migrating _snapptags -> url_tag (best effort)...");

    const urlTagRows = oldSnapptags
      .map((st) => {
        const tId =
          tagIdMap.get(st.tagSlugOrId) ||
          tagIdMap.get(st.tagSlugOrId.toLowerCase());
        if (!tId) return null;
        return { urlId: st.snappId, tagId: tId };
      })
      .filter(
        (x): x is { urlId: string; tagId: string } =>
          x !== null
      );

    for (let i = 0; i < urlTagRows.length; i += CHUNK_SIZE) {
      const chunk = urlTagRows.slice(i, i + CHUNK_SIZE);
      logInfo(
        `Inserting url_tag ${i + 1}–${i + chunk.length} / ${urlTagRows.length}`
      );
      await db.insert(urlToTag).values(chunk).onConflictDoNothing();
    }

    logStep("url_tag relations migrated");
  } else {
    logInfo("No _snapptags found; skipping url_tag migration.");
  }

  // ---- metrics (usages) ---------------------------------------------------
  logStep("Migrating usages -> metric...");

  const validUrlIds = new Set(urlRows.map((u) => String(u.id)));

  const metricRows = oldUsages
    .filter((u) => u.snappId && validUrlIds.has(String(u.snappId)))
    .map((u) => {
      const mappedOwnerId =
        (u.ownerId && legacyToNewUserId.get(String(u.ownerId))) ?? u.ownerId;

      const rawDevice = u.device;
      const device =
        rawDevice === "M obile"
          ? "Mobile"
          : rawDevice === "T ablet"
          ? "Tablet"
          : rawDevice;

      return {
        id: `u_${u.id}`,
        timestamp: safeDate(u.timestamp),
        urlId: u.snappId,
        ownerId: mappedOwnerId,
        organizationId: LEGACY_ORG_ID,
        language: u.language,
        userAgent: u.userAgent,
        referrer: u.referrer,
        device,
        country: u.country,
        region: u.region,
        city: u.city,
        os: u.os,
        browser: u.browser,
        cpu: u.cpu,
        utm: legacyUtmBySnappId.get(String(u.snappId)) ?? {},
      };
    });

  for (let i = 0; i < metricRows.length; i += CHUNK_SIZE) {
    const chunk = metricRows.slice(i, i + CHUNK_SIZE);
    logInfo(
      `Inserting metrics ${i + 1}–${i + chunk.length} / ${metricRows.length}`
    );
    await db
      .insert(metric)
      .values(chunk)
      .onConflictDoNothing({ target: metric.id });
  }

  logStep("Metrics migrated");

  console.log("\n✅ Migration complete!");
  console.log(
    `   Users:   ${oldUsers.length}
   URLs:    ${oldSnapps.length}
   Metrics: ${oldUsages.length}
   Tags:    ${oldTags.length}`
  );

  await client.end();
}

main().catch((err) => {
  console.error("💥 Migration failed:", err);
  process.exit(1);
});