fediglam/src/main/migrations.zig

const std = @import("std");
const sql = @import("sql");
const DateTime = @import("util").DateTime;

pub const Migration = struct {
    name: [:0]const u8,
    up: []const u8,
    down: []const u8,
};

fn firstIndexOf(str: []const u8, char: u8) ?usize {
    for (str) |ch, i| {
        if (ch == char) return i;
    }

    return null;
}

fn execStmt(tx: sql.Tx, stmt: []const u8, alloc: std.mem.Allocator) !void {
    const stmt_null = try std.cstr.addNullByte(alloc, stmt);
    defer alloc.free(stmt_null);
    try tx.exec(stmt_null, .{}, null);
}

fn execScript(db: sql.Db, script: []const u8, alloc: std.mem.Allocator) !void {
    const tx = try db.begin();
    errdefer tx.rollback();

    var remaining = script;
    while (firstIndexOf(remaining, ';')) |last| {
        try execStmt(tx, remaining[0 .. last + 1], alloc);

        remaining = remaining[last + 1 ..];
    }
    if (remaining.len > 1) try execStmt(tx, remaining, alloc);

    try tx.commit();
}

fn wasMigrationRan(db: sql.Db, name: []const u8, alloc: std.mem.Allocator) !bool {
    const row = (try db.queryRow(&.{i32}, "SELECT COUNT(*) FROM migration WHERE name = $1", .{name}, alloc)) orelse return false;
    return row[0] != 0;
}

pub fn up(db: sql.Db) !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    std.log.info("Running migrations...", .{});
    try execScript(db, create_migration_table, gpa.allocator());

    for (migrations) |migration| {
        const was_ran = try wasMigrationRan(db, migration.name, gpa.allocator());
        if (!was_ran) {
            std.log.info("Running migration {s}", .{migration.name});
            try execScript(db, migration.up, gpa.allocator());
            try db.insert("migration", .{ .name = migration.name });
        }
    }
}

const create_migration_table =
    \\CREATE TABLE IF NOT EXISTS
    \\migration(
    \\  name TEXT NOT NULL PRIMARY KEY,
    \\  applied_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
    \\);
;

// NOTE: Until the first public release, i may collapse multiple
// migrations into a single one. this will require db recreation
const migrations: []const Migration = &.{
    .{
        .name = "users",
        .up = 
        \\CREATE TABLE user(
        \\  id TEXT NOT NULL PRIMARY KEY,
        \\  username TEXT NOT NULL,
        \\
        \\  created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
        \\);
        \\
        \\CREATE TABLE local_user(
        \\  user_id TEXT NOT NULL PRIMARY KEY REFERENCES user(id),
        \\
        \\  email TEXT
        \\);
        \\
        \\CREATE TABLE account_password(
        \\  user_id TEXT NOT NULL PRIMARY KEY REFERENCES user(id),
        \\
        \\  hashed_password BLOB NOT NULL
        \\);
        ,
        .down = 
        \\DROP TABLE account_password;
        \\DROP TABLE local_user;
        \\DROP TABLE user;
        ,
    },
    .{
        .name = "notes",
        .up = 
        \\CREATE TABLE note(
        \\  id TEXT NOT NULL,
        \\
        \\  content TEXT NOT NULL,
        \\  author_id TEXT NOT NULL REFERENCES user(id),
        \\
        \\  created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
        \\);
        ,
        .down = "DROP TABLE note;",
    },
    .{
        .name = "note reactions",
        .up = 
        \\CREATE TABLE reaction(
        \\  id TEXT NOT NULL PRIMARY KEY,
        \\
        \\  user_id TEXT NOT NULL REFERENCES user(id),
        \\  note_id TEXT NOT NULL REFERENCES note(id),
        \\
        \\  created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
        \\);
        ,
        .down = "DROP TABLE reaction;",
    },
    .{
        .name = "user tokens",
        .up = 
        \\CREATE TABLE token(
        \\  hash TEXT NOT NULL PRIMARY KEY,
        \\  user_id TEXT NOT NULL REFERENCES local_user(id),
        \\
        \\  issued_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
        \\);
        ,
        .down = "DROP TABLE token;",
    },
    .{
        .name = "user invites",
        .up = 
        \\CREATE TABLE invite(
        \\  id TEXT NOT NULL PRIMARY KEY,
        \\
        \\  name TEXT NOT NULL,
        \\  code TEXT NOT NULL UNIQUE,
        \\  created_by TEXT NOT NULL REFERENCES local_user(id),
        \\
        \\  max_uses INTEGER,
        \\
        \\  created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
        \\  expires_at TIMESTAMPTZ,
        \\
        \\  type TEXT NOT NULL CHECK (type in ('system', 'community_owner', 'user'))
        \\);
        \\ALTER TABLE local_user ADD COLUMN invite_id TEXT REFERENCES invite(id);
        ,
        .down = 
        \\ALTER TABLE local_user DROP COLUMN invite_id;
        \\DROP TABLE invite;
        ,
    },
    .{
        .name = "communities",
        .up = 
        \\CREATE TABLE community(
        \\  id TEXT NOT NULL PRIMARY KEY,
        \\
        \\  owner_id TEXT REFERENCES user(id),
        \\  name TEXT NOT NULL,
        \\  host TEXT NOT NULL UNIQUE,
        \\  scheme TEXT NOT NULL CHECK (scheme IN ('http', 'https')),
        \\
        \\  created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
        \\);
        \\ALTER TABLE user ADD COLUMN community_id TEXT REFERENCES community(id);
        \\ALTER TABLE invite ADD COLUMN to_community TEXT REFERENCES community(id);
        ,
        .down = 
        \\ALTER TABLE invite DROP COLUMN to_community;
        \\ALTER TABLE user DROP COLUMN community_id;
        \\DROP TABLE community;
        ,
    },
};