tiny.sql.repository

1pub fn Repository(comptime Sql: type, comptime Policy: type) type {2    const branch = Sql.branch;3    const history = Sql.history;4    const sync = Sql.sync;5    const version = Sql.version;67    return struct {8        const Database = Policy.Database;9        const Remote = remote_owner.Owner(Sql, Policy);1011        pub const Transfer = struct {12            commits: usize = 0,13            records: usize = 0,14            applied: bool = false,15            merged: bool = false,16            resolved: usize = 0,17        };1819        pub const Head = sync.HeadHex;2021        pub const Status = struct {22            remote: ?[]u8 = null,23            local_head: Head,24            remote_head: ?Head = null,25            ahead: usize = 0,26            behind: usize = 0,27            diverged: bool = false,2829            pub fn deinit(self: *Status, allocator: Allocator) void {30                if (self.remote) |remote_path| allocator.free(remote_path);31                self.* = undefined;32            }33        };3435        pub const writeRemote = Remote.write;36        pub const readRemote = Remote.read;3738        pub fn status(39            allocator: Allocator,40            db: *Database,41            remote_store_dir: ?[]const u8,42        ) !Status {43            const local_ref = (try (try db.history.full()).ref(44                Policy.branch_name,45            )) orelse return error.RefNotFound;46            var result = Status{47                .local_head = sync.headHex(local_ref.target),48            };49            const remote_dir = remote_store_dir orelse return result;5051            result.remote = try allocator.dupe(u8, remote_dir);52            errdefer result.deinit(allocator);5354            var opened_remote = try Remote.open(allocator, remote_dir);55            defer opened_remote.deinit();5657            const related = try sync.historyRelation(58                allocator,59                try db.history.full(),60                &opened_remote.history,61                Policy.branch_name,62            );63            if (related.remote_head) |remote_head| {64                result.remote_head = sync.headHex(remote_head);65            }66            result.ahead = related.ahead;67            result.behind = related.behind;68            result.diverged = related.diverged();69            return result;70        }7172        pub fn push(73            allocator: Allocator,74            workspace: *Database.Workspace,75            db: *Database,76            remote_store_dir: []const u8,77            dry_run: bool,78        ) !Transfer {79            if (try db.dirty()) return error.SyncDirtyStore;8081            if (dry_run) {82                var remote_dir = try Remote.openDir(remote_store_dir);83                defer remote_dir.close(fs_io);84                if (!Remote.historyExists(remote_dir)) {85                    var names = [_][]const u8{Policy.branch_name};86                    var pack = try sync.exportRefNames(87                        allocator,88                        try db.history.full(),89                        names[0..],90                    );91                    defer pack.deinit();92                    return .{93                        .commits = pack.commits.len,94                        .records = pack.frames.len,95                    };96                }97                var opened_remote = try Remote.open(98                    allocator,99                    remote_store_dir,100                );101                defer opened_remote.deinit();102                const related = try sync.historyRelation(103                    allocator,104                    try db.history.full(),105                    &opened_remote.history,106                    Policy.branch_name,107                );108                const planned = sync.planHistoryTransfer(109                    allocator,110                    try db.history.full(),111                    &opened_remote.history,112                    Policy.branch_name,113                    related,114                    .push,115                ) catch |err| return mapHistoryPlanError(err);116                return transferFromPlan(planned);117            }118119            var remote_dir = try Remote.openDir(remote_store_dir);120            defer remote_dir.close(fs_io);121            var lock = try Remote.lock(remote_dir);122            defer lock.close(fs_io);123124            if (try Remote.needsBootstrap(allocator, remote_dir)) {125                if (comptime Policy.validate_transitions) {126                    try Policy.validateSnapshot(127                        allocator,128                        db,129                        try db.headHash(),130                    );131                }132                var remote_history = try history.History.open(133                    allocator,134                    remote_dir,135                    .{ .path = Policy.history_name, .recovery = .reject },136                );137                defer remote_history.deinit();138                const stats = sync.pushFastForward(139                    allocator,140                    try db.history.full(),141                    &remote_history,142                    Policy.branch_name,143                ) catch |err| switch (err) {144                    error.NonFastForward => return error.SyncDiverged,145                    else => return err,146                };147                var remote_db = try Policy.openWrite(148                    allocator,149                    workspace,150                    remote_dir,151                );152                defer remote_db.deinit();153                try remote_db.alignToBranchHead();154                try afterRemoteAlignment(155                    allocator,156                    remote_store_dir,157                    &remote_db,158                );159                return .{160                    .commits = stats.commits,161                    .records = stats.records,162                    .applied = true,163                };164            }165166            var remote_db = try Policy.openWrite(167                allocator,168                workspace,169                remote_dir,170            );171            defer remote_db.deinit();172            if (try remote_db.dirty()) return error.SyncDirtyStore;173174            const related = try sync.historyRelation(175                allocator,176                try db.history.full(),177                try remote_db.history.full(),178                Policy.branch_name,179            );180            if (related.upToDate()) {181                try afterRemoteAlignment(182                    allocator,183                    remote_store_dir,184                    &remote_db,185                );186                return .{};187            }188            if (related.diverged()) return error.SyncDiverged;189            if (related.behind != 0) return error.SyncRemoteAhead;190191            if (comptime Policy.validate_transitions) {192                try Policy.validateTransition(193                    allocator,194                    &remote_db,195                    try remote_db.headHash(),196                    db,197                    try db.headHash(),198                );199            }200201            const stats = sync.pushFastForward(202                allocator,203                try db.history.full(),204                try remote_db.history.full(),205                Policy.branch_name,206            ) catch |err| switch (err) {207                error.NonFastForward => return error.SyncDiverged,208                else => return err,209            };210            try remote_db.alignToBranchHead();211            try afterRemoteAlignment(212                allocator,213                remote_store_dir,214                &remote_db,215            );216            return .{217                .commits = stats.commits,218                .records = stats.records,219                .applied = true,220            };221        }222223        pub fn pull(224            allocator: Allocator,225            workspace: *Database.Workspace,226            db: *Database,227            remote_store_dir: []const u8,228            dry_run: bool,229        ) !Transfer {230            if (try db.dirty()) return error.SyncDirtyStore;231232            var opened_remote = try Remote.open(233                allocator,234                remote_store_dir,235            );236            defer opened_remote.deinit();237            var remote_db: ?Database = null;238            if (comptime @hasDecl(Policy, "openPullDatabase")) {239                remote_db = try Policy.openPullDatabase(240                    allocator,241                    workspace,242                    opened_remote.dir,243                );244            }245            defer if (remote_db) |*db_value| db_value.deinit();246247            const related = try sync.historyRelation(248                allocator,249                try db.history.full(),250                &opened_remote.history,251                Policy.branch_name,252            );253            if (related.diverged()) {254                if (try db.pristine()) {255                    if (dry_run) {256                        return transferFromPlan(try sync.planHistoryAdopt(257                            allocator,258                            try db.history.full(),259                            &opened_remote.history,260                            Policy.branch_name,261                        ));262                    }263                    try validateRemoteTransition(264                        allocator,265                        db,266                        if (remote_db) |*db_value| db_value else null,267                        related.remote_head.?,268                    );269                    return try adopt(270                        allocator,271                        db,272                        &opened_remote.history,273                        related.remote_head.?,274                    );275                }276                if (dry_run) {277                    const planned = try sync.planHistoryAdopt(278                        allocator,279                        try db.history.full(),280                        &opened_remote.history,281                        Policy.branch_name,282                    );283                    var transfer = transferFromPlan(planned);284                    transfer.merged = true;285                    return transfer;286                }287                return try mergePull(288                    allocator,289                    db,290                    &opened_remote.history,291                    related.remote_head.?,292                );293            }294            if (dry_run) {295                const planned = sync.planHistoryTransfer(296                    allocator,297                    try db.history.full(),298                    &opened_remote.history,299                    Policy.branch_name,300                    related,301                    .pull,302                ) catch |err| return mapHistoryPlanError(err);303                return transferFromPlan(planned);304            }305            if (related.upToDate() or related.remote_head == null) return .{};306            if (related.behind == 0) return .{};307308            try validateRemoteTransition(309                allocator,310                db,311                if (remote_db) |*db_value| db_value else null,312                related.remote_head.?,313            );314            const stats = sync.pullFastForward(315                allocator,316                try db.history.full(),317                &opened_remote.history,318                Policy.branch_name,319            ) catch |err| switch (err) {320                error.NonFastForward => return error.SyncDiverged,321                else => return err,322            };323            try db.alignToBranchHead();324            return .{325                .commits = stats.commits,326                .records = stats.records,327                .applied = true,328            };329        }330331        pub fn exportPack(332            allocator: Allocator,333            db: *Database,334            pack_path: []const u8,335        ) !Transfer {336            var pack = try sync.exportAll(allocator, try db.history.full());337            defer pack.deinit();338            const bytes = try sync.encodePack(allocator, &pack);339            defer allocator.free(bytes);340341            var file = try std.Io.Dir.createFileAbsolute(342                fs_io,343                pack_path,344                .{ .truncate = true },345            );346            defer file.close(fs_io);347            try file.writePositionalAll(fs_io, bytes, 0);348            try file.setLength(fs_io, bytes.len);349            try file.sync(fs_io);350            return .{351                .commits = pack.commits.len,352                .records = pack.frames.len,353                .applied = true,354            };355        }356357        pub fn importPack(358            allocator: Allocator,359            db: *Database,360            bytes: []const u8,361            dry_run: bool,362        ) !Transfer {363            if (try db.dirty()) return error.SyncDirtyStore;364365            var pack = try sync.decodePack(allocator, bytes);366            defer pack.deinit();367            const target = sync.packRefTarget(368                &pack,369                Policy.branch_name,370            ) orelse return error.SyncPackBranchMissing;371            const local_ref = (try (try db.history.full()).ref(372                Policy.branch_name,373            )) orelse return error.RefNotFound;374375            if (dry_run) {376                const missing = try sync.missingPackCounts(377                    try db.history.full(),378                    &pack,379                );380                if (version.same(local_ref.target, target)) return .{};381                return transferFromPlan(missing);382            }383384            const stats = try sync.importObjects(try db.history.full(), &pack);385            if (version.same(local_ref.target, target)) return .{};386387            const entries = try (try db.history.full()).commitEntries(allocator);388            defer allocator.free(entries);389            if (!try branch.canFastForward(390                allocator,391                entries,392                local_ref.target,393                target,394            )) {395                if (try branch.canFastForward(396                    allocator,397                    entries,398                    target,399                    local_ref.target,400                )) return .{};401                if (!try db.pristine()) {402                    var transfer = try mergeImported(allocator, db, target);403                    transfer.commits = stats.commits;404                    transfer.records = stats.records;405                    return transfer;406                }407                try validateImportedTransition(408                    allocator,409                    db,410                    local_ref.target,411                    target,412                );413                try db.adoptBranchHead(target);414                return .{415                    .commits = stats.commits,416                    .records = stats.records,417                    .applied = true,418                };419            }420421            try validateImportedTransition(422                allocator,423                db,424                local_ref.target,425                target,426            );427            try db.fastForwardTo(target);428            return .{429                .commits = stats.commits,430                .records = stats.records,431                .applied = true,432            };433        }434435        fn validateRemoteTransition(436            allocator: Allocator,437            db: *Database,438            remote_db: ?*Database,439            remote_head: version.Hash,440        ) !void {441            if (comptime !Policy.validate_transitions) return;442            comptime {443                if (!@hasDecl(Policy, "openPullDatabase")) {444                    @compileError(445                        "transition validation requires openPullDatabase",446                    );447                }448            }449            const target = remote_db orelse unreachable;450            try Policy.validateTransition(451                allocator,452                db,453                try db.headHash(),454                target,455                remote_head,456            );457        }458459        fn validateImportedTransition(460            allocator: Allocator,461            db: *Database,462            current_head: version.Hash,463            target_head: version.Hash,464        ) !void {465            if (comptime !Policy.validate_transitions) return;466            try Policy.validateTransition(467                allocator,468                db,469                current_head,470                db,471                target_head,472            );473        }474475        fn mergePull(476            allocator: Allocator,477            db: *Database,478            remote_history: *const history.History,479            remote_head: version.Hash,480        ) !Transfer {481            var names = [_][]const u8{Policy.branch_name};482            var pack = try sync.exportMissingRefNames(483                allocator,484                remote_history,485                try db.history.full(),486                names[0..],487            );488            defer pack.deinit();489            const stats = try sync.importObjects(try db.history.full(), &pack);490            var transfer = try mergeImported(allocator, db, remote_head);491            transfer.commits = stats.commits;492            transfer.records = stats.records;493            return transfer;494        }495496        fn afterRemoteAlignment(497            allocator: Allocator,498            remote_store_dir: []const u8,499            db: *Database,500        ) !void {501            if (comptime !Policy.reconcile_remote) return;502            try Policy.afterRemoteAlignment(503                allocator,504                remote_store_dir,505                db,506            );507        }508509        fn mergeImported(510            allocator: Allocator,511            db: *Database,512            remote_head: version.Hash,513        ) !Transfer {514            const resolved = try Policy.mergeImported(515                allocator,516                db,517                remote_head,518            );519            return .{520                .applied = true,521                .merged = true,522                .resolved = resolved,523            };524        }525526        fn adopt(527            allocator: Allocator,528            db: *Database,529            remote_history: *const history.History,530            target: version.Hash,531        ) !Transfer {532            var names = [_][]const u8{Policy.branch_name};533            var pack = try sync.exportMissingRefNames(534                allocator,535                remote_history,536                try db.history.full(),537                names[0..],538            );539            defer pack.deinit();540            const stats = try sync.importObjects(try db.history.full(), &pack);541            try db.adoptBranchHead(target);542            return .{543                .commits = stats.commits,544                .records = stats.records,545                .applied = true,546            };547        }548549        fn transferFromPlan(plan: sync.HistoryTransferPlan) Transfer {550            return .{551                .commits = plan.commits,552                .records = plan.records,553            };554        }555556        fn mapHistoryPlanError(err: anyerror) anyerror {557            return switch (err) {558                error.HistoryDiverged => error.SyncDiverged,559                error.HistoryRemoteAhead => error.SyncRemoteAhead,560                else => err,561            };562        }563    };564}

1const flow = @import("flow.zig");23pub const Repository = flow.Repository;

1pub const repository = @import("repository/root.zig");