2023-01-02 20:38:42 +00:00
|
|
|
const std = @import("std");
|
|
|
|
const util = @import("util");
|
|
|
|
|
|
|
|
const Uuid = util.Uuid;
|
|
|
|
const DateTime = util.DateTime;
|
|
|
|
|
2023-01-03 01:21:08 +00:00
|
|
|
const impl = struct {
|
|
|
|
const communities = @import("./services/communities.zig");
|
|
|
|
const actors = @import("./services/actors.zig");
|
|
|
|
const drive = @import("./services/drive.zig");
|
|
|
|
const files = @import("./services/files.zig");
|
|
|
|
const invites = @import("./services/invites.zig");
|
|
|
|
const notes = @import("./services/notes.zig");
|
|
|
|
const follows = @import("./services/follows.zig");
|
|
|
|
const accounts = @import("./services/accounts.zig");
|
|
|
|
const tokens = @import("./services/tokens.zig");
|
|
|
|
};
|
|
|
|
|
|
|
|
const types = @import("./services/types.zig");
|
|
|
|
pub usingnamespace types;
|
|
|
|
|
|
|
|
pub const Account = types.accounts.Account;
|
|
|
|
pub const Credentials = types.accounts.Credentials;
|
|
|
|
pub const Actor = types.actors.Actor;
|
|
|
|
pub const Community = types.communities.Community;
|
|
|
|
pub const DriveEntry = types.drive.DriveEntry;
|
|
|
|
pub const FileUpload = types.files.FileUpload;
|
|
|
|
pub const Invite = types.invites.Invite;
|
|
|
|
pub const Note = types.notes.Note;
|
|
|
|
pub const Token = types.tokens.Token;
|
2023-01-02 20:38:42 +00:00
|
|
|
|
|
|
|
pub fn Services(comptime Db: type) type {
|
|
|
|
return struct {
|
|
|
|
const Self = @This();
|
|
|
|
|
|
|
|
db: Db,
|
|
|
|
|
|
|
|
pub fn beginTx(self: Self) !Services(Db.BeginOrSavepoint) {
|
|
|
|
return Services(Db.BeginOrSavepoint){
|
|
|
|
.db = try self.db.beginOrSavepoint(),
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn commitTx(self: Self) !void {
|
|
|
|
return try self.db.commitOrRelease();
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn rollbackTx(self: Self) void {
|
|
|
|
return self.db.rollback();
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn createAccount(
|
|
|
|
self: Self,
|
|
|
|
alloc: std.mem.Allocator,
|
2023-01-08 23:35:58 +00:00
|
|
|
args: types.accounts.CreateArgs,
|
2023-01-03 01:17:42 +00:00
|
|
|
) !void {
|
2023-01-08 23:35:58 +00:00
|
|
|
return try impl.accounts.create(self.db, args, alloc);
|
2023-01-02 20:38:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn getCredentialsByUsername(
|
|
|
|
self: Self,
|
|
|
|
alloc: std.mem.Allocator,
|
|
|
|
username: []const u8,
|
|
|
|
community_id: Uuid,
|
|
|
|
) !Credentials {
|
2023-01-03 01:21:08 +00:00
|
|
|
return try impl.accounts.getCredentialsByUsername(self.db, username, community_id, alloc);
|
2023-01-02 20:38:42 +00:00
|
|
|
}
|
|
|
|
|
2023-01-03 01:17:42 +00:00
|
|
|
pub fn createActor(
|
|
|
|
self: Self,
|
|
|
|
alloc: std.mem.Allocator,
|
|
|
|
username: []const u8,
|
|
|
|
community_id: Uuid,
|
|
|
|
lax_username: bool, // TODO: remove this
|
|
|
|
) !Uuid {
|
2023-01-03 01:21:08 +00:00
|
|
|
return try impl.actors.create(self.db, username, community_id, lax_username, alloc);
|
2023-01-03 01:17:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn getActor(
|
|
|
|
self: Self,
|
|
|
|
alloc: std.mem.Allocator,
|
|
|
|
user_id: Uuid,
|
|
|
|
) !Actor {
|
2023-01-03 01:21:08 +00:00
|
|
|
return try impl.actors.get(self.db, user_id, alloc);
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn lookupActorByUsername(
|
|
|
|
self: Self,
|
|
|
|
alloc: std.mem.Allocator,
|
|
|
|
username: []const u8,
|
|
|
|
community_id: Uuid,
|
|
|
|
) !Actor {
|
|
|
|
return try impl.actors.lookupByUsername(self.db, username, community_id, alloc);
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn updateActorProfile(
|
|
|
|
self: Self,
|
|
|
|
alloc: std.mem.Allocator,
|
|
|
|
actor_id: Uuid,
|
|
|
|
new: types.actors.ProfileUpdateArgs,
|
2023-01-04 19:03:23 +00:00
|
|
|
) !void {
|
2023-01-03 01:21:08 +00:00
|
|
|
return try impl.actors.updateProfile(self.db, actor_id, new, alloc);
|
2023-01-03 01:17:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn createCommunity(
|
|
|
|
self: Self,
|
|
|
|
alloc: std.mem.Allocator,
|
|
|
|
origin: []const u8,
|
2023-01-03 01:21:08 +00:00
|
|
|
options: types.communities.CreateOptions,
|
2023-01-03 01:17:42 +00:00
|
|
|
) !Uuid {
|
2023-01-03 01:21:08 +00:00
|
|
|
return try impl.communities.create(self.db, origin, options, alloc);
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn getCommunity(
|
|
|
|
self: Self,
|
|
|
|
alloc: std.mem.Allocator,
|
|
|
|
id: Uuid,
|
|
|
|
) !Community {
|
|
|
|
return try impl.communities.get(self.db, id, alloc);
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn getCommunityByHost(
|
|
|
|
self: Self,
|
|
|
|
alloc: std.mem.Allocator,
|
|
|
|
host: []const u8,
|
|
|
|
) !Community {
|
|
|
|
return try impl.communities.getByHost(self.db, host, alloc);
|
2023-01-03 01:17:42 +00:00
|
|
|
}
|
|
|
|
|
2023-01-04 19:03:23 +00:00
|
|
|
pub fn getAdminCommunityId(self: Self) !Uuid {
|
|
|
|
return try impl.communities.adminCommunityId(self.db);
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn transferCommunityOwnership(self: Self, community_id: Uuid, owner_id: Uuid) !void {
|
2023-01-03 01:21:08 +00:00
|
|
|
return try impl.communities.transferOwnership(self.db, community_id, owner_id);
|
|
|
|
}
|
|
|
|
|
2023-01-04 19:03:23 +00:00
|
|
|
pub fn queryCommunities(
|
|
|
|
self: Self,
|
|
|
|
alloc: std.mem.Allocator,
|
|
|
|
args: types.communities.QueryArgs,
|
|
|
|
) !types.communities.QueryResult {
|
|
|
|
return try impl.communities.query(self.db, args, alloc);
|
|
|
|
}
|
|
|
|
|
2023-01-03 01:21:08 +00:00
|
|
|
pub fn statDriveEntry(
|
|
|
|
self: Self,
|
|
|
|
alloc: std.mem.Allocator,
|
|
|
|
owner_id: Uuid,
|
|
|
|
path: []const u8,
|
|
|
|
) !DriveEntry {
|
|
|
|
return try impl.drive.stat(self.db, owner_id, path, alloc);
|
|
|
|
}
|
|
|
|
|
2023-01-04 19:25:08 +00:00
|
|
|
pub fn getDriveEntry(
|
|
|
|
self: Self,
|
|
|
|
alloc: std.mem.Allocator,
|
|
|
|
id: Uuid,
|
|
|
|
) !DriveEntry {
|
|
|
|
return try impl.drive.get(self.db, id, alloc);
|
|
|
|
}
|
|
|
|
|
2023-01-03 01:21:08 +00:00
|
|
|
pub fn createDriveEntry(
|
|
|
|
self: Self,
|
|
|
|
alloc: std.mem.Allocator,
|
|
|
|
owner_id: Uuid,
|
|
|
|
containing_path: []const u8,
|
|
|
|
name: []const u8,
|
|
|
|
file_id: ?Uuid,
|
|
|
|
) !Uuid {
|
|
|
|
return try impl.drive.create(self.db, owner_id, containing_path, name, file_id, alloc);
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn deleteDriveEntry(
|
|
|
|
self: Self,
|
|
|
|
alloc: std.mem.Allocator,
|
|
|
|
entry_id: Uuid,
|
|
|
|
) !void {
|
|
|
|
return try impl.drive.delete(self.db, entry_id, alloc);
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn moveDriveEntry(
|
|
|
|
self: Self,
|
|
|
|
alloc: std.mem.Allocator,
|
|
|
|
owner_id: Uuid,
|
|
|
|
src: []const u8,
|
|
|
|
dest: []const u8,
|
|
|
|
) !void {
|
|
|
|
return try impl.drive.move(self.db, owner_id, src, dest, alloc);
|
|
|
|
}
|
|
|
|
|
|
|
|
// TODO: paginate
|
|
|
|
pub fn listDriveEntry(
|
|
|
|
self: Self,
|
|
|
|
alloc: std.mem.Allocator,
|
2023-01-04 19:03:23 +00:00
|
|
|
entry_id: Uuid,
|
2023-01-03 01:21:08 +00:00
|
|
|
) ![]DriveEntry {
|
2023-01-04 19:03:23 +00:00
|
|
|
return try impl.drive.list(self.db, entry_id, alloc);
|
2023-01-03 01:21:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn createFile(
|
|
|
|
self: Self,
|
|
|
|
alloc: std.mem.Allocator,
|
|
|
|
owner_id: Uuid,
|
|
|
|
meta: types.files.CreateOptions,
|
|
|
|
data: []const u8,
|
|
|
|
) !Uuid {
|
|
|
|
return try impl.files.create(self.db, owner_id, meta, data, alloc);
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn deleteFile(
|
|
|
|
self: Self,
|
|
|
|
alloc: std.mem.Allocator,
|
|
|
|
id: Uuid,
|
|
|
|
) !void {
|
|
|
|
return try impl.files.delete(self.db, id, alloc);
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn statFile(
|
|
|
|
self: Self,
|
|
|
|
alloc: std.mem.Allocator,
|
|
|
|
id: Uuid,
|
|
|
|
) !FileUpload {
|
|
|
|
return try impl.files.get(self.db, id, alloc);
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn derefFile(
|
|
|
|
_: Self,
|
|
|
|
alloc: std.mem.Allocator,
|
|
|
|
id: Uuid,
|
|
|
|
) ![]const u8 {
|
|
|
|
return try impl.files.deref(alloc, id);
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn updateFileMetadata(
|
|
|
|
self: Self,
|
|
|
|
alloc: std.mem.Allocator,
|
|
|
|
id: Uuid,
|
|
|
|
meta: types.files.UpdateArgs,
|
2023-01-04 19:03:23 +00:00
|
|
|
) !void {
|
2023-01-03 01:21:08 +00:00
|
|
|
return try impl.files.update(self.db, id, meta, alloc);
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn createFollow(
|
|
|
|
self: Self,
|
|
|
|
alloc: std.mem.Allocator,
|
|
|
|
followed_by: Uuid,
|
|
|
|
followee: Uuid,
|
|
|
|
) !void {
|
|
|
|
return try impl.follows.create(self.db, followed_by, followee, alloc);
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn deleteFollow(
|
|
|
|
self: Self,
|
|
|
|
alloc: std.mem.Allocator,
|
|
|
|
followed_by: Uuid,
|
|
|
|
followee: Uuid,
|
|
|
|
) !void {
|
|
|
|
return try impl.follows.delete(self.db, followed_by, followee, alloc);
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn queryFollows(
|
|
|
|
self: Self,
|
|
|
|
alloc: std.mem.Allocator,
|
|
|
|
args: types.follows.QueryArgs,
|
|
|
|
) !types.follows.QueryResult {
|
|
|
|
return try impl.follows.query(self.db, args, alloc);
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn createInvite(
|
|
|
|
self: Self,
|
|
|
|
alloc: std.mem.Allocator,
|
|
|
|
options: types.invites.CreateOptions,
|
2023-01-04 19:03:23 +00:00
|
|
|
) !Uuid {
|
|
|
|
return try impl.invites.create(self.db, options, alloc);
|
2023-01-03 01:21:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn getInvite(
|
|
|
|
self: Self,
|
|
|
|
alloc: std.mem.Allocator,
|
|
|
|
invite_id: Uuid,
|
|
|
|
) !Invite {
|
|
|
|
return try impl.invites.get(self.db, invite_id, alloc);
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn createNote(
|
|
|
|
self: Self,
|
|
|
|
alloc: std.mem.Allocator,
|
|
|
|
author_id: Uuid,
|
|
|
|
content: []const u8,
|
|
|
|
) !Uuid {
|
|
|
|
return try impl.notes.create(self.db, author_id, content, alloc);
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn getNote(
|
|
|
|
self: Self,
|
|
|
|
alloc: std.mem.Allocator,
|
|
|
|
id: Uuid,
|
|
|
|
) !Note {
|
|
|
|
return try impl.notes.get(self.db, id, alloc);
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn queryNotes(
|
|
|
|
self: Self,
|
|
|
|
alloc: std.mem.Allocator,
|
|
|
|
args: types.notes.QueryArgs,
|
|
|
|
) !types.notes.QueryResult {
|
|
|
|
return try impl.notes.query(self.db, args, alloc);
|
2023-01-03 01:17:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn getInviteByCode(
|
|
|
|
self: Self,
|
|
|
|
alloc: std.mem.Allocator,
|
|
|
|
code: []const u8,
|
|
|
|
community_id: Uuid,
|
|
|
|
) !Invite {
|
2023-01-03 01:21:08 +00:00
|
|
|
return try impl.invites.getByCode(self.db, code, community_id, alloc);
|
2023-01-03 01:17:42 +00:00
|
|
|
}
|
|
|
|
|
2023-01-02 20:38:42 +00:00
|
|
|
pub fn createToken(
|
|
|
|
self: Self,
|
|
|
|
alloc: std.mem.Allocator,
|
|
|
|
account_id: Uuid,
|
|
|
|
hash: []const u8,
|
|
|
|
) !void {
|
2023-01-03 01:21:08 +00:00
|
|
|
return try impl.tokens.create(self.db, account_id, hash, alloc);
|
2023-01-02 20:38:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn getTokenByHash(
|
|
|
|
self: Self,
|
|
|
|
alloc: std.mem.Allocator,
|
|
|
|
hash: []const u8,
|
|
|
|
community_id: Uuid,
|
|
|
|
) !Token {
|
2023-01-03 01:21:08 +00:00
|
|
|
return try impl.tokens.getByHash(self.db, hash, community_id, alloc);
|
2023-01-02 20:38:42 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|