push source

1 files changed, 568 insertions, 0 deletions

diff --git a/backend/api/src/userdata.zig b/backend/api/src/userdata.zig
new file mode 100644
index 0000000..f16e126
--- /dev/null
+++ b/backend/api/src/userdata.zig
@@ -0,0 +1,568 @@
+const z = @import( "std" );
+const db = @import( "db.zig" );
+const zap = @import( "zap" );
+const req = @import( "req.zig" );
+const net = @import( "net-util.zig" );
+const model = @import( "model.zig" );
+
+const u = struct {
+  usingnamespace @import( "util.zig" );
+  usingnamespace @import( "userdefs.zig" );
+  usingnamespace @import( "user.zig" );
+};
+
+const alloc = u.alloc;
+
+const ArenaAllocator = z.heap.ArenaAllocator;
+const ArrayList = z.ArrayList;
+const UserEntry = u.UserEntry;
+const ErrorRes = u.ErrorRes;
+const OkRes = net.OkResponse;
+
+const bufprint = z.fmt.bufPrint;
+const memeql = z.mem.eql;
+
+pub const routes = .{
+  .@"settings" = settings,
+  .@"get-notes" = getNotes,
+  .@"getalldata" = getAllData,
+  .@"delete-note" = deleteNote,
+  .@"delete-notes" = deleteNotes,
+  .@"update-settings" = updateSettingsRoute
+};
+
+pub const ChatEntry = struct {
+  id: []const u8,
+  name: []const u8,
+};
+
+pub const ChatFiles = struct {
+  files: ?[]ChatEntry,
+};
+
+const PrefsDbEntry = struct {
+  uuid: []const u8,
+  nickname: []const u8,
+  prompt_data: []const u8,
+  site_prefs: []const u8,
+  chat_files: []const u8
+};
+
+const PrefsPromptData = struct {
+  system: ?[]const u8 = ""
+};
+
+const PrefsSiteData = struct {
+  font: ?[]const u8 = "Terminal",
+  model: ?[]const u8 = null
+};
+
+pub const Prefs = struct {
+  uuid: []const u8,
+  nickname: []const u8,
+  prompt_data: PrefsPromptData = .{},
+  site_prefs: PrefsSiteData = .{},
+  chat_files: ?ChatFiles = null,
+  db_entry: ?db.Row(PrefsDbEntry) = null,
+
+  pub const @"getty.sb" = struct {
+    pub const attributes = .{
+      .db_entry = .{ .skip = true },
+    };
+  };
+};
+
+const PrefsResponse = struct {
+  uuid: []const u8,
+  nickname: []const u8,
+  prompt_data: PrefsPromptData = .{},
+  site_prefs: PrefsSiteData = .{},
+  chat_files: ?ChatFiles = null,
+  plan: u.SubData,
+
+  pub fn fromPrefs( prefs: *const Prefs, user: *const u.UserEntry ) PrefsResponse {
+    return PrefsResponse {
+      .uuid = prefs.uuid,
+      .nickname = prefs.nickname,
+      .prompt_data = prefs.prompt_data,
+      .site_prefs = prefs.site_prefs,
+      .chat_files = prefs.chat_files,
+      .plan = user.subscription_data
+    };
+  }
+};
+
+const NoteEntry = struct {
+  content: []const u8,
+  id: []const u8
+};
+
+const NoteTargetReq = struct {
+  noteId: []const u8,
+
+  pub const @"getty.db" = u.@"json.ignore.unknown";
+};
+
+/// creates directories for notes and chats
+pub fn createDirectories() void {
+  var pathbuf: [256]u8 = undefined;
+  const notes_path = bufprint( &pathbuf, "../data/notes", .{} ) catch unreachable;
+  var notes_dir = z.fs.cwd().openDir( notes_path, .{} ) catch r: {
+    z.fs.cwd().makeDir( notes_path ) catch {};
+    break :r null;
+  }; if( notes_dir ) |*c| c.close();
+
+  const chats_path = bufprint( &pathbuf, "../data/chats", .{} ) catch unreachable;
+  var chats_dir = z.fs.cwd().openDir( chats_path, .{} ) catch r: {
+    z.fs.cwd().makeDir( chats_path ) catch {};
+    break :r null;
+  }; if( chats_dir ) |*c| c.close();
+}
+
+pub const UpdateReqParams = struct {
+  pub const @"getty.db" = u.@"json.ignore.unknown";
+
+  prefs: struct {
+    prompt_data: ?PrefsPromptData = null,
+    site_prefs: ?PrefsSiteData = null,
+    nickname: ?[]const u8 = null,
+
+    pub const @"getty.db" = u.@"json.ignore.unknown";
+  } = .{},
+
+  pub fn isValid( self: @This(), user: *const UserEntry ) !bool {
+    if( self.prefs.prompt_data ) |p| {
+      if( p.system ) |s| {
+        if( !u.Validator.isValidStrSystem( s ) )
+          return error.InvalidSystemPrompt;
+      }
+    }
+    if( self.prefs.nickname ) |name| {
+      if( !u.Validator.isValidStrNickname( name ) )
+        return error.InvalidNickname;
+    }
+    if( self.prefs.site_prefs ) |p| {
+      if( p.font )  |f| if( !u.Validator.isValidStrFont( f ) ) return error.InvalidSiteFont;
+      if( p.model ) |m| {
+        if( !u.Validator.isValidStrFont( m ) ) return error.InvalidModel; // todo later: check if model exists within modelmap
+
+        const models = model.loadModels() catch return error.ModelMapError;
+        for( models.v ) |mod| {
+          if( memeql( u8, m, mod.name ) ) {
+            return model.canBeUsedByUser( mod, user );
+          }
+        }
+
+        return error.InvalidModel;
+      }
+    }
+
+    return true;
+  }
+};
+
+fn dbToPrefs( row: *db.Row(PrefsDbEntry) ) !Prefs {
+  const a = row.alloc.allocator();
+  const prompt = try u.jsonParseAlloc( PrefsPromptData, row.v.prompt_data, a );
+  const site = try u.jsonParseAlloc( PrefsSiteData, row.v.site_prefs, a );
+  const chat = try u.jsonParseAlloc( ChatFiles, row.v.chat_files, a );
+
+  return Prefs{
+    .uuid = row.v.uuid,
+    .nickname = row.v.nickname,
+    .prompt_data = prompt.v,
+    .site_prefs = site.v,
+    .chat_files = chat.v,
+    .db_entry = row.*
+  };
+}
+
+fn prefsToDb( prefs: Prefs, arena: *ArenaAllocator ) !PrefsDbEntry {
+  const a = arena.allocator();
+  const prompt = try u.jsonStringifyAlloc( prefs.prompt_data, a );
+  const site = try u.jsonStringifyAlloc( prefs.site_prefs, a );
+  const chat = try u.jsonStringifyAlloc( prefs.chat_files, a );
+
+  return PrefsDbEntry {
+    .uuid = prefs.uuid,
+    .nickname = prefs.nickname,
+    .prompt_data = prompt,
+    .site_prefs = site,
+    .chat_files = chat
+  };
+}
+
+pub fn getSettings( uuid: []const u8 ) !Prefs {
+  const query = "SELECT * FROM user_data WHERE uuid = ?";
+  var res = try u.dbi.oneAlloc( PrefsDbEntry, query, .{ .uuid = uuid } );
+  return dbToPrefs( &res );
+}
+
+fn getSettingsDbEntry( uuid: []const u8 ) !db.Row(PrefsDbEntry) {
+  const query = "SELECT * FROM user_data WHERE uuid = ?";
+  const res = try u.dbi.oneAlloc( PrefsDbEntry, query, .{ .uuid = uuid } );
+  return res;
+}
+
+fn createNewSettings( name: []const u8, uuid: []const u8 ) !Prefs {
+  var arena = z.heap.ArenaAllocator.init( alloc );
+  const a = arena.allocator();
+  defer arena.deinit();
+
+
+  const models = model.loadModels() catch null;
+  var modelname: []const u8 = "qwen2.5:1.5b";
+  if( models ) |mods| {
+    for( mods.v ) |mod| {
+      if( mod.free == 1 ) {
+        modelname = a.dupe( u8, mod.name ) catch "";
+        break;
+      }
+    }
+  }
+
+  const prefs = Prefs {
+    .uuid = uuid,
+    .nickname = name,
+    .site_prefs = .{ .font = "Terminal", .model = modelname },
+    .prompt_data = .{ .system = "" },
+    .chat_files = .{ .files = &[_]ChatEntry{} }
+  };
+
+  const converted = try prefsToDb( prefs, &arena );
+  const query = "INSERT INTO user_data (uuid, nickname, site_prefs, prompt_data, chat_files) VALUES (?, ?, ?, ?, ?)";
+  try u.dbi.put( query, .{
+    .uuid = converted.uuid,
+    .nickname = converted.nickname,
+    .site_prefs = converted.site_prefs,
+    .prompt_data = converted.prompt_data,
+    .chat_files = converted.chat_files
+  } );
+
+  // return the actual entry - if it fails then we panic
+  return getSettings( uuid );
+}
+
+fn updateSettingsFromParams( oldprefs: *Prefs, newprefs: *UpdateReqParams, user: *const UserEntry ) !void {
+  _ = try newprefs.isValid( user );
+
+  if( newprefs.prefs.site_prefs ) |site| {
+    if( site.model ) |m| oldprefs.site_prefs.model = m;
+    if( site.font ) |f| oldprefs.site_prefs.font = f;
+  }
+  if( newprefs.prefs.nickname ) |nickname| {
+    oldprefs.nickname = nickname;
+  }
+  if( newprefs.prefs.prompt_data ) |prompt_data| {
+    oldprefs.prompt_data = prompt_data;
+  }
+
+  var arena = z.heap.ArenaAllocator.init( alloc );
+  defer arena.deinit();
+
+  const converted = prefsToDb( oldprefs.*, &arena ) catch return error.JsonParseError;
+  const query = "UPDATE user_data SET site_prefs = ?, nickname = ?, prompt_data = ? WHERE uuid = ?";
+
+  return u.dbi.put( query, .{
+    .site_prefs = converted.site_prefs,
+    .nickname = converted.nickname,
+    .prompt_data = converted.prompt_data,
+    .uuid = converted.uuid,
+  } );
+}
+
+pub fn hasChat( prefs: *Prefs, id: []const u8 ) bool {
+  if( prefs.chat_files == null )
+    return false;
+
+  if( prefs.chat_files.?.files == null )
+    return false;
+
+  const files = prefs.chat_files.?.files.?;
+  for( files ) |file| {
+    if( memeql( u8, file.id, id ) )
+      return true;
+  }
+
+  return false;
+}
+
+pub fn updateSettings( newprefs: *Prefs ) !void {
+  try u.checkDbOnThread();
+
+  var arena = ArenaAllocator.init( alloc );
+  const a = arena.allocator();
+  defer arena.deinit();
+
+  const prefs = u.jsonStringifyAlloc( newprefs.site_prefs, a ) catch return error.InvalidSitePrefs;
+  const prompt_data = u.jsonStringifyAlloc( newprefs.prompt_data, a ) catch return error.InvalidPromptData;
+  const chat_files = u.jsonStringifyAlloc( newprefs.chat_files, a ) catch return error.InvalidChatFiles;
+
+  const nickname = newprefs.nickname;
+  const uuid = newprefs.uuid;
+
+  const query = "UPDATE user_data SET site_prefs = ?, nickname = ?, prompt_data = ?, chat_files = ? WHERE uuid = ?";
+  return u.dbi.put( query, .{
+    .site_prefs = prefs,
+    .nickname = nickname,
+    .prompt_data = prompt_data,
+    .chat_files = chat_files,
+    .uuid = uuid,
+  } );
+}
+
+///route @/settings
+fn settings( r: zap.Request ) void {
+  u.checkDbOnThread() catch {
+    return net.sendJson( r, .internal_server_error, ErrorRes{ .msg = "internal server error" } );
+  };
+  if( net.handleInvalidPostReq( r ) ) return;
+
+  var decoded = u.apiTokenFromPostReq( r ) catch return;
+  defer decoded.deinit();
+
+  var user = u.getEntry( decoded.claims.uuid ) catch |e| {
+    switch( e ) {
+      error.QueryError => return net.sendJson( r, .not_found, ErrorRes{ .msg = "user not found" } ),
+      else => return net.sendJson( r, .internal_server_error, ErrorRes{ .msg = "internal_server_error" } )
+    }
+  }; defer user.db_entry.?.deinit();
+
+  var entry = getSettings( decoded.claims.uuid ) catch |e| {
+    switch( e ) {
+      error.QueryError => return net.sendJson( r, .not_found, ErrorRes{ .status = "nodata", .msg = "no user data found. is this account not activated?" } ),
+      else => {
+        z.debug.print( "error getting settings: {s} {any} {any}\n", .{ decoded.claims.uuid, e, @errorReturnTrace() } );
+        return net.sendJson( r, .internal_server_error, ErrorRes{ .msg = "internal server error" } );
+      }
+    }
+  }; defer entry.db_entry.?.deinit();
+
+  return net.sendJson( r, .ok, OkRes( .{ .userprefs = PrefsResponse.fromPrefs( &entry, &user ) } ) );
+}
+
+///route @/update-settings
+fn updateSettingsRoute( r: zap.Request ) void {
+  u.checkDbOnThread() catch {
+    return net.sendJson( r, .internal_server_error, ErrorRes{ .msg = "internal server error" } );
+  };
+  if( net.handleInvalidPostReq( r ) ) return;
+
+  var decoded = u.tokenFromPostReq( r ) catch return;
+  defer decoded.deinit();
+
+  var user = u.getEntry( decoded.claims.uuid ) catch {
+    return net.sendJson( r, .not_found, ErrorRes{ .msg = "user not found" } );
+  }; defer user.db_entry.?.deinit();
+
+  var entry = getSettings( user.uuid ) catch |e| r: {
+    switch( e ) {
+      error.QueryError => break :r createNewSettings( "user", user.uuid ) catch {
+        z.debug.print( "error querying settings: {s} {any}", .{ user.uuid, @errorReturnTrace() } );
+        return net.sendJson( r, .internal_server_error, ErrorRes{ .msg = "internal server error" } );
+      },
+      else => return net.sendJson( r, .internal_server_error, ErrorRes{ .msg = "internal server error" } )
+    }
+  }; defer { if( entry.db_entry ) |e| e.deinit(); }
+
+  var params = u.jsonParse( UpdateReqParams, r.body.? ) catch {
+    return net.sendJson( r, .bad_request, ErrorRes{ .msg = "invalid request body" } );
+  }; defer params.deinit();
+
+  updateSettingsFromParams( &entry, &params.v, &user ) catch |e| {
+    switch( e ) {
+      error.JsonParseError => return net.sendJson( r, .bad_request, ErrorRes{ .msg = "invalid request body" } ),
+      error.InvalidNickname => return net.sendJson( r, .bad_request, ErrorRes{ .msg = "invalid field: nickname" } ),
+      error.InvalidSiteFont => return net.sendJson( r, .bad_request, ErrorRes{ .msg = "invalid field: site_font" } ),
+      error.InvalidSystemPrompt => return net.sendJson( r, .bad_request, ErrorRes{ .msg = "invalid field: system_prompt" } ),
+      error.InvalidModel => return net.sendJson( r, .bad_request, ErrorRes{ .msg = "invalid field: model" } ),
+      else => {
+        z.debug.print( "error updating settings: {s} {any}", .{ entry.uuid, @errorReturnTrace() } );
+        return net.sendJson( r, .internal_server_error, ErrorRes{.msg = "internal server error" } );
+      }
+    }
+  };
+
+  return net.sendJson( r, .ok, OkRes( .{
+    .msg = "settings updated successfully",
+    .userprefs = PrefsResponse.fromPrefs( &entry, &user )
+  } ) );
+}
+
+fn readNotesFile( uuid: []const u8 ) !u.JsonResponse([]NoteEntry) {
+  var buf: [256]u8 = undefined;
+  const path = z.fmt.bufPrint( &buf, "../data/notes/{s}-notes.json", .{ uuid } ) catch "";
+
+  const contents = u.readFileCrypto( path ) catch {
+    return error.IOError;
+  }; defer alloc.free( contents );
+
+  const json = u.jsonParse( []NoteEntry, contents ) catch {
+    return error.ParseError;
+  };
+
+  return json;
+}
+
+fn saveNotesFile( uuid: []const u8, notes: []NoteEntry ) !void {
+  var buf: [256]u8 = undefined;
+  const path = z.fmt.bufPrint( &buf, "../data/notes/{s}-notes.json", .{ uuid } ) catch "";
+
+  const contents = u.jsonStringify( notes ) catch {
+    return error.EncodeError;
+  }; defer alloc.free( contents );
+
+  const stdout = u.writeFileCrypto( path, contents ) catch |e| {
+    z.debug.print( "Failed to write file: {any}", .{ e } );
+    return error.IOError;
+  };
+
+  alloc.free( stdout );
+}
+
+///route @/get-notes
+fn getNotes( r: zap.Request ) void {
+  u.checkDbOnThread() catch {
+    return net.sendJson( r, .internal_server_error, ErrorRes{ .msg = "internal server error" } );
+  };
+  if( net.handleInvalidPostReq( r ) ) return;
+
+  const uuid = u.uuidFromApiOrAuthToken( r ) catch return;
+  defer alloc.free( uuid );
+
+  const notes = readNotesFile( uuid ) catch |e| {
+    switch( e ) {
+      error.IOError => return net.sendJson( r, .ok, OkRes( .{ .notes = [_]NoteEntry{} } ) ),
+      error.ParseError => return net.sendJson( r, .internal_server_error, ErrorRes{ .msg = "error parsing notes file" } )
+    }
+  }; defer notes.deinit();
+
+  return net.sendJson( r, .ok, OkRes( .{ .notes = notes.v } ) );
+}
+
+///route @/delete-note
+fn deleteNote( r: zap.Request ) void {
+  u.checkDbOnThread() catch {
+    return net.sendJson( r, .internal_server_error, ErrorRes{ .msg = "internal server error" } );
+  };
+  if( net.handleInvalidPostReq( r ) ) return;
+
+  const uuid = u.uuidFromApiOrAuthToken( r ) catch return;
+  defer alloc.free( uuid );
+
+  const params = u.jsonParse( NoteTargetReq, r.body.? ) catch {
+    z.debug.print( "{s}\n", .{ r.body.? } );
+    return net.sendJson( r, .bad_request, ErrorRes{ .msg = "invalid request format" } );
+  }; defer params.deinit();
+
+  const notes = readNotesFile( uuid ) catch |e| {
+    switch( e ) {
+      error.IOError => return net.sendJson( r, .not_found, ErrorRes{ .msg = "note not found" } ),
+      error.ParseError => return net.sendJson( r, .internal_server_error, ErrorRes{ .msg = "error parsing notes file" } )
+    }
+  }; defer notes.deinit();
+
+  var list = ArrayList( NoteEntry ).init( alloc );
+  defer list.deinit();
+  for( notes.v ) |note| {
+    if( !memeql( u8, note.id, params.v.noteId ) )
+      list.append( note ) catch {};
+  }
+
+  saveNotesFile( uuid, list.items ) catch {
+    return net.sendJson( r, .internal_server_error, ErrorRes{ .msg = "error saving notes file" } );
+  };
+
+  return net.sendJson( r, .ok, OkRes( .{ .msg = "note deleted" } ) );
+}
+
+///route @/delete-notes
+fn deleteNotes( r: zap.Request ) void {
+  u.checkDbOnThread() catch {
+    return net.sendJson( r, .internal_server_error, ErrorRes{ .msg = "internal server error" } );
+  };
+  if( net.handleInvalidPostReq( r ) ) return;
+
+  const uuid = u.uuidFromApiOrAuthToken( r ) catch return;
+  defer alloc.free( uuid );
+
+  var buf: [256]u8 = undefined;
+  const path = z.fmt.bufPrint( &buf, "../data/notes/{s}-notes.json", .{ uuid } ) catch "";
+
+  z.fs.cwd().deleteFile( path ) catch |e| {
+    switch ( e ) {
+      error.FileNotFound => return net.sendJson( r, .not_found, ErrorRes{ .msg = "no notes found" } ),
+      else => return net.sendJson( r, .internal_server_error, ErrorRes{ .msg = "internal server error" } ),
+    }
+  };
+
+  net.sendJson( r, .ok, OkRes( .{ .msg = "notes deleted" } ) );
+}
+
+fn aggregateUserData( uuid: []const u8 ) ![]const u8 {
+  const userdata = try getSettings( uuid );
+  defer userdata.db_entry.?.deinit();
+
+  const json = try u.jsonStringify( userdata );
+  defer alloc.free( json );
+
+  const wrapped_json = try u.jsonStringify( json );
+  defer alloc.free( wrapped_json );
+
+  const proc = try z.process.Child.run( .{
+    .allocator = alloc,
+    .argv = &.{ "node", "../data-aggregate.cjs", wrapped_json }
+  } );
+  defer alloc.free( proc.stdout );
+  defer alloc.free( proc.stderr );
+
+  while( true ) {
+    if( proc.term == .Exited )
+      break;
+    z.Thread.yield() catch {};
+  }
+
+  if( proc.stderr.len > 0 )
+    z.debug.print( "{s}\n", .{ proc.stderr } );
+  if( proc.stdout.len > 0 and proc.stdout[0] == '0' ) {
+    z.debug.print( "{s}\n", .{ proc.stdout } );
+    return error.ReadError;
+  }
+
+  const copy = alloc.dupe( u8, proc.stdout );
+  return copy;
+}
+
+///route @/getalldata
+fn getAllData( r: zap.Request ) void {
+  if( net.handleInvalidPostReq( r ) ) return;
+  u.checkDbOnThread() catch return;
+
+  var token = u.tokenFromPostReq( r ) catch return;
+  defer token.deinit();
+  const user = u.getEntry( token.claims.uuid ) catch {
+    return net.sendJson( r, .unauthorized, ErrorRes{ .msg = "user not found" } );
+  };
+  defer user.db_entry.?.deinit();
+
+  const data = aggregateUserData( user.uuid ) catch |e| {
+    z.debug.print( "error aggregating data: {any} {any}", .{ e, @errorReturnTrace() } );
+    return net.sendJson( r, .internal_server_error, ErrorRes{ .msg = "internal server error" } );
+  };
+  defer alloc.free( data );
+
+  var path_buf: [256]u8 = undefined;
+  const path = z.fmt.bufPrint( &path_buf, "/tmp/{s}.zip", .{ user.uuid } ) catch {
+    return net.sendJson( r, .internal_server_error, ErrorRes{ .msg = "internal server error" } );
+  };
+
+  u.writeFile( path, data ) catch |e| {
+    z.debug.print( "error writing file: {any} {any}", .{ e, @errorReturnTrace() } );
+    return net.sendJson( r, .internal_server_error, ErrorRes{ .msg = "internal server error" } );
+  };
+  r.setHeader( "Content-Type", "application/zip" ) catch {};
+  r.setHeader( "Content-Disposition", "attachment; filename=userdata.zip" ) catch {};
+  r.sendFile( path ) catch |e| {
+    z.debug.print( "error sending file: {any} {any}", .{ e, @errorReturnTrace() } );
+  };
+}