halkyon-days/halkyon
Watch
1
0
Fork
You've already forked halkyon
 0
Code Issues Pull requests Projects Releases 40 Packages Wiki Activity Actions

feat(meditate): dreams on the server, sealed and synced like the sittings

Browse source 
The dream journal's table (ADR 0038, D14): `dream`, in the sync engine's
database, a row a dream, its content sealed on the device (key ID,
payload, nonce), so the instance sees only that a dream exists, its size
and when it changed. The same rules as the sittings: the sync engine's
connector refuses a call without a session, each row lives in its
person's space, and deleting the person deletes their dreams with it
(the deletion test now writes and counts a dream too, and leaves
another person's).

The migration `20261103130213716-dreams`:
- `CREATE OR REPLACE FUNCTION gen_random_uuid_v7()`: the generator
  repeats the UUID v7 function every migration; replacing it with the
  same body changes nothing.
- `CREATE TABLE "dream"`: `id` a UUID v7 by default, `spaceId` the
  person's sync space, `keyId` the key it is sealed with, `payload` the
  sealed bytes (not null), `nonce` the sealing's nonce.
- `CREATE INDEX "dream_space_idx"` on `spaceId`, so deleting a space
  finds its dreams without scanning the table.
- The foreign key from `spaceId` to `offline_sync_spaces("id")` with
  `ON DELETE CASCADE`: deleting the space deletes its dreams.
- The version rows of every module in `serverpod_migrations`.
A new, empty table: nothing existing changes and no data moves.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Signed-off-by: Tizian 「ティツィアーン」 <raisondetredev@pm.me>
This commit is contained in:
Tizian 「ティツィアーン」 2026-11-03 14:04:57 +01:00
commit 769ae3b20a
Signed by: raisondetredev
GPG key ID: 07F6FCF405488B64
5 changed files with 18526 additions and 7 deletions
Download patch file Download diff file Expand all files Collapse all files

670
apps/meditate/halkyon_meditate_server/lib/src/generated/journal/dream.dart Normal file
View file

@ -0,0 +1,670 @@
/* AUTOMATICALLY GENERATED CODE DO NOT MODIFY */
/* To generate run: "serverpod generate" */
// ignore_for_file: implementation_imports
// ignore_for_file: library_private_types_in_public_api
// ignore_for_file: non_constant_identifier_names
// ignore_for_file: public_member_api_docs
// ignore_for_file: type_literal_in_constant_pattern
// ignore_for_file: use_super_parameters
// ignore_for_file: invalid_use_of_internal_member
// ignore_for_file: no_leading_underscores_for_library_prefixes
import 'dart:typed_data' as _idt;
import 'package:serverpod/serverpod.dart' as _is;
/// A dream the person wrote down (ADR 0038, D14): the night it belongs to,
/// its title and text, its marks (lucid, nightmare, recurring), its clarity,
/// the mood on waking, its labels and when it was written, all in its sealed
/// payload; the instance sees that it exists, its size and when it changed.
/// Changed and deleted by the person alone. Synced.
abstract class Dream
implements _is.TableRow<_is.UuidValue?>, _is.ProtocolSerialization {
Dream._({
this.id,
this.spaceId,
this.keyId,
required this.payload,
this.nonce,
});
factory Dream({
_is.UuidValue? id,
int? spaceId,
String? keyId,
required _idt.ByteData payload,
_idt.ByteData? nonce,
}) = _DreamImpl;
factory Dream.fromJson(Map<String, dynamic> jsonSerialization) {
return Dream(
id: jsonSerialization['id'] == null
? null
: _is.UuidValueJsonExtension.fromJson(jsonSerialization['id']),
spaceId: jsonSerialization['spaceId'] as int?,
keyId: jsonSerialization['keyId'] as String?,
payload: _is.ByteDataJsonExtension.fromJson(jsonSerialization['payload']),
nonce: jsonSerialization['nonce'] == null
? null
: _is.ByteDataJsonExtension.fromJson(jsonSerialization['nonce']),
);
}
static final t = DreamTable();
static const db = DreamRepository._();
@override
_is.UuidValue? id;
/// The space owning this row. Maintained by the sync engine.
int? spaceId;
/// The key it is sealed with (ADR 0002's envelope); never null in Meditate,
/// where everything is sealed.
String? keyId;
/// The content, sealed: UTF-8 JSON with a `schemaVersion` once opened.
_idt.ByteData payload;
/// The sealing's nonce (ADR 0002's envelope).
_idt.ByteData? nonce;
@override
_is.Table<_is.UuidValue?> get table => t;
/// Returns a shallow copy of this [Dream]
/// with some or all fields replaced by the given arguments.
@_is.useResult
Dream copyWith({
_is.UuidValue? id,
int? spaceId,
String? keyId,
_idt.ByteData? payload,
_idt.ByteData? nonce,
});
@override
Map<String, dynamic> toJson() {
return {
'__className__': 'Dream',
if (id != null) 'id': id?.toJson(),
if (spaceId != null) 'spaceId': spaceId,
if (keyId != null) 'keyId': keyId,
'payload': payload.toJson(),
if (nonce != null) 'nonce': nonce?.toJson(),
};
}
@override
Map<String, dynamic> toJsonForProtocol() {
return {
'__className__': 'Dream',
if (id != null) 'id': id?.toJson(),
if (spaceId != null) 'spaceId': spaceId,
if (keyId != null) 'keyId': keyId,
'payload': payload.toJson(),
if (nonce != null) 'nonce': nonce?.toJson(),
};
}
static DreamInclude include() {
return DreamInclude._();
}
static DreamIncludeList includeList({
_is.WhereExpressionBuilder<DreamTable>? where,
int? limit,
int? offset,
_is.OrderByBuilder<DreamTable>? orderBy,
_is.OrderByListBuilder<DreamTable>? orderByList,
DreamInclude? include,
}) {
return DreamIncludeList._(
where: where,
limit: limit,
offset: offset,
orderBy: orderBy?.call(Dream.t),
orderByList: orderByList?.call(Dream.t),
include: include,
);
}
@override
String toString() {
return _is.SerializationManager.encode(this);
}
}
class _Undefined {}
class _DreamImpl extends Dream {
_DreamImpl({
_is.UuidValue? id,
int? spaceId,
String? keyId,
required _idt.ByteData payload,
_idt.ByteData? nonce,
}) : super._(
id: id,
spaceId: spaceId,
keyId: keyId,
payload: payload,
nonce: nonce,
);
/// Returns a shallow copy of this [Dream]
/// with some or all fields replaced by the given arguments.
@_is.useResult
@override
Dream copyWith({
Object? id = _Undefined,
Object? spaceId = _Undefined,
Object? keyId = _Undefined,
_idt.ByteData? payload,
Object? nonce = _Undefined,
}) {
return Dream(
id: id is _is.UuidValue? ? id : this.id,
spaceId: spaceId is int? ? spaceId : this.spaceId,
keyId: keyId is String? ? keyId : this.keyId,
payload: payload ?? this.payload.clone(),
nonce: nonce is _idt.ByteData? ? nonce : this.nonce?.clone(),
);
}
}
class DreamUpdateTable extends _is.UpdateTable<DreamTable> {
DreamUpdateTable(super.table);
_is.ColumnValue<int, int> spaceId(int? value) => _is.ColumnValue(
table.spaceId,
value,
);
_is.ColumnValue<String, String> keyId(String? value) => _is.ColumnValue(
table.keyId,
value,
);
_is.ColumnValue<_idt.ByteData, _idt.ByteData> payload(_idt.ByteData value) =>
_is.ColumnValue(
table.payload,
value,
);
_is.ColumnValue<_idt.ByteData, _idt.ByteData> nonce(_idt.ByteData? value) =>
_is.ColumnValue(
table.nonce,
value,
);
}
class DreamTable extends _is.Table<_is.UuidValue?> {
DreamTable({super.tableRelation}) : super(tableName: 'dream') {
updateTable = DreamUpdateTable(this);
spaceId = _is.ColumnInt(
'spaceId',
this,
);
keyId = _is.ColumnString(
'keyId',
this,
);
payload = _is.ColumnByteData(
'payload',
this,
);
nonce = _is.ColumnByteData(
'nonce',
this,
);
}
late final DreamUpdateTable updateTable;
/// The space owning this row. Maintained by the sync engine.
late final _is.ColumnInt spaceId;
/// The key it is sealed with (ADR 0002's envelope); never null in Meditate,
/// where everything is sealed.
late final _is.ColumnString keyId;
/// The content, sealed: UTF-8 JSON with a `schemaVersion` once opened.
late final _is.ColumnByteData payload;
/// The sealing's nonce (ADR 0002's envelope).
late final _is.ColumnByteData nonce;
@override
List<_is.Column> get columns => [
id,
spaceId,
keyId,
payload,
nonce,
];
}
class DreamInclude extends _is.IncludeObject {
DreamInclude._();
@override
Map<String, _is.Include?> get includes => {};
@override
_is.Table<_is.UuidValue?> get table => Dream.t;
}
class DreamIncludeList extends _is.IncludeList {
DreamIncludeList._({
_is.WhereExpressionBuilder<DreamTable>? where,
super.limit,
super.offset,
super.orderBy,
super.orderByList,
super.include,
}) {
super.where = where?.call(Dream.t);
}
@override
Map<String, _is.Include?> get includes => include?.includes ?? {};
@override
_is.Table<_is.UuidValue?> get table => Dream.t;
}
class DreamRepository {
const DreamRepository._();
/// Returns a list of [Dream]s matching the given query parameters.
///
/// Use [where] to specify which items to include in the return value.
/// If none is specified, all items will be returned.
///
/// To specify the order of the items use [orderBy] or [orderByList]
/// when sorting by multiple columns.
///
/// The maximum number of items can be set by [limit]. If no limit is set,
/// all items matching the query will be returned.
///
/// [offset] defines how many items to skip, after which [limit] (or all)
/// items are read from the database.
///
/// ```dart
/// var persons = await Persons.db.find(
/// session,
/// where: (t) => t.lastName.equals('Jones'),
/// orderBy: (t) => t.firstName,
/// limit: 100,
/// );
/// ```
Future<List<Dream>> find(
_is.DatabaseSession session, {
_is.WhereExpressionBuilder<DreamTable>? where,
int? limit,
int? offset,
_is.OrderByBuilder<DreamTable>? orderBy,
_is.OrderByListBuilder<DreamTable>? orderByList,
_is.Transaction? transaction,
_is.LockMode? lockMode,
_is.LockBehavior? lockBehavior,
}) async {
return session.db.find<Dream>(
where: where?.call(Dream.t),
orderBy: orderBy?.call(Dream.t),
orderByList: orderByList?.call(Dream.t),
limit: limit,
offset: offset,
transaction: transaction,
lockMode: lockMode,
lockBehavior: lockBehavior,
);
}
/// Returns the first matching [Dream] matching the given query parameters.
///
/// Use [where] to specify which items to include in the return value.
/// If none is specified, all items will be returned.
///
/// To specify the order use [orderBy] or [orderByList]
/// when sorting by multiple columns.
///
/// [offset] defines how many items to skip, after which the next one will be picked.
///
/// ```dart
/// var youngestPerson = await Persons.db.findFirstRow(
/// session,
/// where: (t) => t.lastName.equals('Jones'),
/// orderBy: (t) => t.age,
/// );
/// ```
Future<Dream?> findFirstRow(
_is.DatabaseSession session, {
_is.WhereExpressionBuilder<DreamTable>? where,
int? offset,
_is.OrderByBuilder<DreamTable>? orderBy,
_is.OrderByListBuilder<DreamTable>? orderByList,
_is.Transaction? transaction,
_is.LockMode? lockMode,
_is.LockBehavior? lockBehavior,
}) async {
return session.db.findFirstRow<Dream>(
where: where?.call(Dream.t),
orderBy: orderBy?.call(Dream.t),
orderByList: orderByList?.call(Dream.t),
offset: offset,
transaction: transaction,
lockMode: lockMode,
lockBehavior: lockBehavior,
);
}
/// Finds a single [Dream] by its [id] or null if no such row exists.
Future<Dream?> findById(
_is.DatabaseSession session,
_is.UuidValue id, {
_is.Transaction? transaction,
_is.LockMode? lockMode,
_is.LockBehavior? lockBehavior,
}) async {
return session.db.findById<Dream>(
id,
transaction: transaction,
lockMode: lockMode,
lockBehavior: lockBehavior,
);
}
/// Inserts all [Dream]s in the list and returns the inserted rows.
///
/// The returned [Dream]s will have their `id` fields set.
///
/// This is an atomic operation, meaning that if one of the rows fails to
/// insert, none of the rows will be inserted.
///
/// If [ignoreConflicts] is set to `true`, rows that conflict with existing
/// rows are silently skipped, and only the successfully inserted rows are
/// returned.
///
/// If [noReturn] is set to `true`, the inserted rows are not read back from
/// the database and an empty list is returned. This avoids the overhead of
/// transferring and deserializing the rows when the result is not needed.
Future<List<Dream>> insert(
_is.DatabaseSession session,
List<Dream> rows, {
_is.Transaction? transaction,
bool ignoreConflicts = false,
bool noReturn = false,
}) async {
return session.db.insert<Dream>(
rows,
transaction: transaction,
ignoreConflicts: ignoreConflicts,
noReturn: noReturn,
);
}
/// Inserts a single [Dream] and returns the inserted row.
///
/// The returned [Dream] will have its `id` field set.
Future<Dream> insertRow(
_is.DatabaseSession session,
Dream row, {
_is.Transaction? transaction,
}) async {
return session.db.insertRow<Dream>(
row,
transaction: transaction,
);
}
/// Upserts all [Dream]s in the list and returns the resulting rows.
///
/// If a row conflicts on the given [conflictColumns], the existing row is
/// updated with the new values. Otherwise, a new row is inserted.
///
/// If [updateColumns] is provided, only those columns will be updated on
/// conflict. If null, all non-conflict, non-id columns are updated.
///
/// If [updateWhere] is provided, the update only applies to rows matching the
/// given expression. Conflicting rows that don't match are skipped and not
/// returned, so the resulting list may be shorter than [rows].
///
/// The returned [Dream]s will have their `id` fields set.
///
/// This is an atomic operation, meaning that if one of the rows fails,
/// none of the rows will be affected.
///
/// If [noReturn] is set to `true`, the resulting rows are not read back from
/// the database and an empty list is returned. This avoids the overhead of
/// transferring and deserializing the rows when the result is not needed.
Future<List<Dream>> upsert(
_is.DatabaseSession session,
List<Dream> rows, {
required _is.ColumnSelections<DreamTable> conflictColumns,
_is.ColumnSelections<DreamTable>? updateColumns,
_is.WhereExpressionBuilder<DreamTable>? updateWhere,
_is.Transaction? transaction,
bool noReturn = false,
}) async {
return session.db.upsert<Dream>(
rows,
conflictColumns: conflictColumns(Dream.t),
updateColumns: updateColumns?.call(Dream.t),
updateWhere: updateWhere?.call(Dream.t),
transaction: transaction,
noReturn: noReturn,
);
}
/// Upserts a single [Dream] and returns the resulting row.
///
/// If the row conflicts on the given [conflictColumns], the existing row is
/// updated. Otherwise, a new row is inserted.
///
/// If [updateColumns] is provided, only those columns will be updated on
/// conflict. If null, all non-conflict, non-id columns are updated.
///
/// If [updateWhere] is provided, the update only applies when the existing
/// row matches the expression. Returns `null` if no row was affected — for
/// example when [updateWhere] does not match the conflicting row.
///
/// The returned [Dream] will have its `id` field set.
Future<Dream?> upsertRow(
_is.DatabaseSession session,
Dream row, {
required _is.ColumnSelections<DreamTable> conflictColumns,
_is.ColumnSelections<DreamTable>? updateColumns,
_is.WhereExpressionBuilder<DreamTable>? updateWhere,
_is.Transaction? transaction,
}) async {
return session.db.upsertRow<Dream>(
row,
conflictColumns: conflictColumns(Dream.t),
updateColumns: updateColumns?.call(Dream.t),
updateWhere: updateWhere?.call(Dream.t),
transaction: transaction,
);
}
/// Updates all [Dream]s in the list and returns the updated rows. If
/// [columns] is provided, only those columns will be updated. Defaults to
/// all columns.
/// This is an atomic operation, meaning that if one of the rows fails to
/// update, none of the rows will be updated.
///
/// If [noReturn] is set to `true`, the updated rows are not read back from
/// the database and an empty list is returned. This avoids the overhead of
/// transferring and deserializing the rows when the result is not needed.
Future<List<Dream>> update(
_is.DatabaseSession session,
List<Dream> rows, {
_is.ColumnSelections<DreamTable>? columns,
_is.Transaction? transaction,
bool noReturn = false,
}) async {
return session.db.update<Dream>(
rows,
columns: columns?.call(Dream.t),
transaction: transaction,
noReturn: noReturn,
);
}
/// Updates a single [Dream]. The row needs to have its id set.
/// Optionally, a list of [columns] can be provided to only update those
/// columns. Defaults to all columns.
Future<Dream> updateRow(
_is.DatabaseSession session,
Dream row, {
_is.ColumnSelections<DreamTable>? columns,
_is.Transaction? transaction,
}) async {
return session.db.updateRow<Dream>(
row,
columns: columns?.call(Dream.t),
transaction: transaction,
);
}
/// Updates a single [Dream] by its [id] with the specified [columnValues].
/// Returns the updated row or null if no row with the given id exists.
Future<Dream?> updateById(
_is.DatabaseSession session,
_is.UuidValue id, {
required _is.ColumnValueListBuilder<DreamUpdateTable> columnValues,
_is.Transaction? transaction,
}) async {
return session.db.updateById<Dream>(
id,
columnValues: columnValues(Dream.t.updateTable),
transaction: transaction,
);
}
/// Updates all [Dream]s matching the [where] expression with the specified [columnValues].
/// Returns the list of updated rows.
///
/// If [noReturn] is set to `true`, the updated rows are not read back from
/// the database and an empty list is returned. This avoids the overhead of
/// transferring and deserializing the rows when the result is not needed.
Future<List<Dream>> updateWhere(
_is.DatabaseSession session, {
required _is.ColumnValueListBuilder<DreamUpdateTable> columnValues,
required _is.WhereExpressionBuilder<DreamTable> where,
int? limit,
int? offset,
_is.OrderByBuilder<DreamTable>? orderBy,
_is.OrderByListBuilder<DreamTable>? orderByList,
_is.Transaction? transaction,
bool noReturn = false,
}) async {
return session.db.updateWhere<Dream>(
columnValues: columnValues(Dream.t.updateTable),
where: where(Dream.t),
limit: limit,
offset: offset,
orderBy: orderBy?.call(Dream.t),
orderByList: orderByList?.call(Dream.t),
transaction: transaction,
noReturn: noReturn,
);
}
/// Deletes all [Dream]s in the list and returns the deleted rows.
///
/// To specify the order of the returned rows use [orderBy] or [orderByList]
/// when sorting by multiple columns.
///
/// This is an atomic operation, meaning that if one of the rows fail to
/// be deleted, none of the rows will be deleted.
///
/// If [noReturn] is set to `true`, the deleted rows are not read back from
/// the database and an empty list is returned. This avoids the overhead of
/// transferring and deserializing the rows when the result is not needed.
Future<List<Dream>> delete(
_is.DatabaseSession session,
List<Dream> rows, {
_is.OrderByBuilder<DreamTable>? orderBy,
_is.OrderByListBuilder<DreamTable>? orderByList,
_is.Transaction? transaction,
bool noReturn = false,
}) async {
return session.db.delete<Dream>(
rows,
orderBy: orderBy?.call(Dream.t),
orderByList: orderByList?.call(Dream.t),
transaction: transaction,
noReturn: noReturn,
);
}
/// Deletes a single [Dream].
Future<Dream> deleteRow(
_is.DatabaseSession session,
Dream row, {
_is.Transaction? transaction,
}) async {
return session.db.deleteRow<Dream>(
row,
transaction: transaction,
);
}
/// Deletes all rows matching the [where] expression.
///
/// To specify the order of the returned rows use [orderBy] or [orderByList]
/// when sorting by multiple columns.
///
/// If [noReturn] is set to `true`, the deleted rows are not read back from
/// the database and an empty list is returned. This avoids the overhead of
/// transferring and deserializing the rows when the result is not needed.
Future<List<Dream>> deleteWhere(
_is.DatabaseSession session, {
required _is.WhereExpressionBuilder<DreamTable> where,
_is.OrderByBuilder<DreamTable>? orderBy,
_is.OrderByListBuilder<DreamTable>? orderByList,
_is.Transaction? transaction,
bool noReturn = false,
}) async {
return session.db.deleteWhere<Dream>(
where: where(Dream.t),
orderBy: orderBy?.call(Dream.t),
orderByList: orderByList?.call(Dream.t),
transaction: transaction,
noReturn: noReturn,
);
}
/// Counts the number of rows matching the [where] expression. If omitted,
/// will return the count of all rows in the table.
Future<int> count(
_is.DatabaseSession session, {
_is.WhereExpressionBuilder<DreamTable>? where,
int? limit,
_is.Transaction? transaction,
}) async {
return session.db.count<Dream>(
where: where?.call(Dream.t),
limit: limit,
transaction: transaction,
);
}
/// Acquires row-level locks on [Dream] rows matching the [where] expression.
Future<void> lockRows(
_is.DatabaseSession session, {
required _is.WhereExpressionBuilder<DreamTable> where,
required _is.LockMode lockMode,
required _is.Transaction transaction,
_is.LockBehavior lockBehavior = _is.LockBehavior.wait,
}) async {
return session.db.lockRows<Dream>(
where: where(Dream.t),
lockMode: lockMode,
lockBehavior: lockBehavior,
transaction: transaction,
);
}
}

83
apps/meditate/halkyon_meditate_server/lib/src/generated/protocol.dart
View file

@ -21,9 +21,11 @@ import 'package:serverpod_auth_idp_server/serverpod_auth_idp_server.dart'
as _iais;
import 'package:serverpod_offline_sync_server/serverpod_offline_sync_server.dart'
as _izehhkf5;
import 'journal/dream.dart' as _is2va3v7;
import 'privacy/content_key.dart' as _imed3x5d;
import 'settings/meditate_settings.dart' as _iutacwgf;
import 'sitting/sitting.dart' as _ic8w2fbu;
export 'journal/dream.dart';
export 'privacy/content_key.dart';
export 'settings/meditate_settings.dart';
export 'sitting/sitting.dart';
@ -98,6 +100,73 @@ class Protocol extends _is.DatabaseSerializationManager {
],
managed: true,
),
_isp.TableDefinition(
name: 'dream',
dartName: 'Dream',
schema: 'public',
module: 'halkyon_meditate',
columns: [
_isp.ColumnDefinition(
name: 'id',
columnType: _isp.ColumnType.uuid,
isNullable: false,
dartType: 'UuidValue?',
columnDefault: 'random_v7',
),
_isp.ColumnDefinition(
name: 'spaceId',
columnType: _isp.ColumnType.bigint,
isNullable: true,
dartType: 'int?',
),
_isp.ColumnDefinition(
name: 'keyId',
columnType: _isp.ColumnType.text,
isNullable: true,
dartType: 'String?',
),
_isp.ColumnDefinition(
name: 'payload',
columnType: _isp.ColumnType.bytea,
isNullable: false,
dartType: 'dart:typed_data:ByteData',
),
_isp.ColumnDefinition(
name: 'nonce',
columnType: _isp.ColumnType.bytea,
isNullable: true,
dartType: 'dart:typed_data:ByteData?',
),
],
foreignKeys: [
_isp.ForeignKeyDefinition(
constraintName: 'dream_fk_0',
columns: ['spaceId'],
referenceTable: 'offline_sync_spaces',
referenceTableSchema: 'public',
referenceColumns: ['id'],
onUpdate: _isp.ForeignKeyAction.noAction,
onDelete: _isp.ForeignKeyAction.cascade,
matchType: null,
),
],
indexes: [
_isp.IndexDefinition(
indexName: 'dream_space_idx',
tableSpace: null,
elements: [
_isp.IndexElementDefinition(
type: _isp.IndexElementDefinitionType.column,
definition: 'spaceId',
),
],
type: 'btree',
isUnique: false,
isPrimary: false,
),
],
managed: true,
),
_isp.TableDefinition(
name: 'meditate_settings',
dartName: 'MeditateSettings',
@ -267,6 +336,9 @@ class Protocol extends _is.DatabaseSerializationManager {
}
}
if (t == _is2va3v7.Dream) {
return _is2va3v7.Dream.fromJson(data) as T;
}
if (t == _imed3x5d.ContentKey) {
return _imed3x5d.ContentKey.fromJson(data) as T;
}
@ -276,6 +348,9 @@ class Protocol extends _is.DatabaseSerializationManager {
if (t == _ic8w2fbu.Sitting) {
return _ic8w2fbu.Sitting.fromJson(data) as T;
}
if (t == _is.getType<_is2va3v7.Dream?>()) {
return (data != null ? _is2va3v7.Dream.fromJson(data) : null) as T;
}
if (t == _is.getType<_imed3x5d.ContentKey?>()) {
return (data != null ? _imed3x5d.ContentKey.fromJson(data) : null) as T;
}
@ -309,6 +384,7 @@ class Protocol extends _is.DatabaseSerializationManager {
static String? getClassNameForType(Type type) {
return switch (type) {
_is2va3v7.Dream => 'Dream',
_imed3x5d.ContentKey => 'ContentKey',
_iutacwgf.MeditateSettings => 'MeditateSettings',
_ic8w2fbu.Sitting => 'Sitting',
@ -329,6 +405,8 @@ class Protocol extends _is.DatabaseSerializationManager {
}
switch (data) {
case _is2va3v7.Dream():
return 'Dream';
case _imed3x5d.ContentKey():
return 'ContentKey';
case _iutacwgf.MeditateSettings():
@ -375,6 +453,9 @@ class Protocol extends _is.DatabaseSerializationManager {
if (dataClassName is! String) {
return super.deserializeByClassName(data);
}
if (dataClassName == 'Dream') {
return deserialize<_is2va3v7.Dream>(data['data']);
}
if (dataClassName == 'ContentKey') {
return deserialize<_imed3x5d.ContentKey>(data['data']);
}
@ -458,6 +539,8 @@ class Protocol extends _is.DatabaseSerializationManager {
}
}
switch (t) {
case _is2va3v7.Dream:
return _is2va3v7.Dream.t;
case _imed3x5d.ContentKey:
return _imed3x5d.ContentKey.t;
case _iutacwgf.MeditateSettings:

2
apps/meditate/halkyon_meditate_server/lib/src/generated/sync_tables.dart
View file

@ -11,6 +11,7 @@
// ignore_for_file: no_leading_underscores_for_library_prefixes
import 'package:serverpod/serverpod.dart' as _is;
import 'journal/dream.dart' as _is2va3v7;
import 'privacy/content_key.dart' as _imed3x5d;
import 'settings/meditate_settings.dart' as _iutacwgf;
import 'sitting/sitting.dart' as _ic8w2fbu;
@ -20,6 +21,7 @@ import 'sitting/sitting.dart' as _ic8w2fbu;
/// shared packages.
final List<_is.Table> syncTables = [
_imed3x5d.ContentKey.t,
_is2va3v7.Dream.t,
_iutacwgf.MeditateSettings.t,
_ic8w2fbu.Sitting.t,
];

20
apps/meditate/halkyon_meditate_server/lib/src/journal/dream.spy.yaml Normal file
View file

@ -0,0 +1,20 @@
### A dream the person wrote down (ADR 0038, D14): the night it belongs to,
### its title and text, its marks (lucid, nightmare, recurring), its clarity,
### the mood on waking, its labels and when it was written, all in its sealed
### payload; the instance sees that it exists, its size and when it changed.
### Changed and deleted by the person alone. Synced.
class: Dream
table: dream
database: sync
fields:
### The key it is sealed with (ADR 0002's envelope); never null in Meditate,
### where everything is sealed.
keyId: String?
### The content, sealed: UTF-8 JSON with a `schemaVersion` once opened.
payload: ByteData
### The sealing's nonce (ADR 0002's envelope).
nonce: ByteData?
indexes:
# Deleting a space finds its rows through this index (see content_key).
dream_space_idx:
fields: spaceId

4
apps/meditate/halkyon_meditate_server/lib/src/meditate_data.dart
View file

@ -7,8 +7,8 @@ import 'package:serverpod_offline_sync_server/serverpod_offline_sync_server.dart
/// sessions ended (a device with a valid session would upload everything
/// again) and before their identities and the person go. Their personal
/// space goes with everything in it: the foreign keys cascade into every
/// synced table (their keys, sittings and settings, ADR 0038, D7) and the
/// sync engine's bookkeeping.
/// synced table (their keys, sittings, settings and dreams, ADR 0038,
/// D7 and D14) and the sync engine's bookkeeping.
Future<AfterDeletion?> deleteMeditateData(
Session session,
UuidValue authUserId,