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

feat(server): studysets, the first synced table (migration pending)

Browse source 
Adopts serverpod_offline_sync v0.0.8 (ADR 0001): its module (nickname offline_sync) and the experimental database: sync in generator.yaml, its server and client packages, and overrides that keep the four Serverpod core packages on v4.0.2, since the package pins v4.0.0 exactly and the spike showed it works on v4.0.2. The app's new dependencies come along because the workspace shares one lock file.

Studyset is the first synced model. Its space owns it, so it has no owner column, and only the envelope is a column: keyId and nonce stay null (no end-to-end encryption; ADR 0002, rule 6), and payload holds the content as versioned UTF-8 JSON, so a new content field changes the payload's schema version instead of this table, whose every migration locks older app versions out of syncing (rule 3). The audience column of the original design is gone: it served key selection, and the engine's spaces decide who reads a row.

The generated server and client code is included. The migration isn't: it is created together with the move to Serverpod v4.0.3 and reviewed first, like the client's local migration (the client's lib/migrations is still empty).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Signed-off-by: Tizian 「ティツィアーン」 <raisondetredev@pm.me>
This commit is contained in:
Tizian 「ティツィアーン」 2026-09-30 10:11:24 +02:00
commit 6769598df5
Signed by: raisondetredev
GPG key ID: 07F6FCF405488B64
9 changed files with 1817 additions and 20 deletions
Download patch file Download diff file Expand all files Collapse all files

9
halkyon_learn_server/config/generator.yaml
View file

@ -2,3 +2,12 @@ type: server
client_package_path: ../halkyon_learn_client
server_test_tools_path: test/integration/test_tools
# Private and shared data sync through serverpod_offline_sync (ADR 0001): its module,
# and the experimental `database: sync` for the models it syncs.
modules:
serverpod_offline_sync:
nickname: offline_sync
experimental_features:
databaseSync: true

4
halkyon_learn_server/lib/src/generated/endpoints.dart
View file

@ -15,6 +15,8 @@ import 'package:serverpod_auth_core_server/serverpod_auth_core_server.dart'
as _iacs;
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 '../auth/anonymous_idp_endpoint.dart' as _in0zita6;
import '../auth/devices_endpoint.dart' as _iduct7ue;
@ -98,6 +100,8 @@ class Endpoints extends _is.EndpointDispatch {
);
modules['serverpod_auth_idp'] = _iais.Endpoints()
..initializeEndpoints(server);
modules['serverpod_offline_sync'] = _izehhkf5.Endpoints()
..initializeEndpoints(server);
modules['serverpod_auth_core'] = _iacs.Endpoints()
..initializeEndpoints(server);
}

98
halkyon_learn_server/lib/src/generated/protocol.dart
View file

@ -19,10 +19,15 @@ import 'package:serverpod_auth_core_server/serverpod_auth_core_server.dart'
as _iacs;
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 'auth/device.dart' as _i6c5ny7n;
import 'common/not_found_exception.dart' as _i8oee73b;
import 'studyset/studyset.dart' as _ikbclmae;
export 'auth/device.dart';
export 'common/not_found_exception.dart';
export 'studyset/studyset.dart';
export 'sync_tables.dart';
class Protocol extends _is.DatabaseSerializationManager {
Protocol._();
@ -32,7 +37,61 @@ class Protocol extends _is.DatabaseSerializationManager {
static final Protocol _instance = Protocol._().._registerHostProtocols();
static List<_isp.TableDefinition> get targetTableDefinitions => [
_isp.TableDefinition(
name: 'studyset',
dartName: 'Studyset',
schema: 'public',
module: 'halkyon_learn',
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: 'studyset_fk_0',
columns: ['spaceId'],
referenceTable: 'offline_sync_spaces',
referenceTableSchema: 'public',
referenceColumns: ['id'],
onUpdate: _isp.ForeignKeyAction.noAction,
onDelete: _isp.ForeignKeyAction.cascade,
matchType: null,
),
],
indexes: [],
managed: true,
),
..._iais.Protocol.targetTableDefinitions,
..._izehhkf5.Protocol.targetTableDefinitions,
..._iacs.Protocol.targetTableDefinitions,
..._isp.Protocol.targetTableDefinitions,
];
@ -70,6 +129,9 @@ class Protocol extends _is.DatabaseSerializationManager {
if (t == _i8oee73b.NotFoundException) {
return _i8oee73b.NotFoundException.fromJson(data) as T;
}
if (t == _ikbclmae.Studyset) {
return _ikbclmae.Studyset.fromJson(data) as T;
}
if (t == _is.getType<_i6c5ny7n.Device?>()) {
return (data != null ? _i6c5ny7n.Device.fromJson(data) : null) as T;
}
@ -77,6 +139,9 @@ class Protocol extends _is.DatabaseSerializationManager {
return (data != null ? _i8oee73b.NotFoundException.fromJson(data) : null)
as T;
}
if (t == _is.getType<_ikbclmae.Studyset?>()) {
return (data != null ? _ikbclmae.Studyset.fromJson(data) : null) as T;
}
if (t == List<_ipdmo8cq.Device>) {
return (data as List)
.map((e) => deserialize<_ipdmo8cq.Device>(e))
@ -86,6 +151,9 @@ class Protocol extends _is.DatabaseSerializationManager {
try {
return _iais.Protocol().deserialize<T>(data, t);
} on _is.DeserializationTypeNotFoundException catch (_) {}
try {
return _izehhkf5.Protocol().deserialize<T>(data, t);
} on _is.DeserializationTypeNotFoundException catch (_) {}
try {
return _iacs.Protocol().deserialize<T>(data, t);
} on _is.DeserializationTypeNotFoundException catch (_) {}
@ -99,6 +167,7 @@ class Protocol extends _is.DatabaseSerializationManager {
return switch (type) {
_i6c5ny7n.Device => 'Device',
_i8oee73b.NotFoundException => 'NotFoundException',
_ikbclmae.Studyset => 'Studyset',
_ => null,
};
}
@ -120,6 +189,8 @@ class Protocol extends _is.DatabaseSerializationManager {
return 'Device';
case _i8oee73b.NotFoundException():
return 'NotFoundException';
case _ikbclmae.Studyset():
return 'Studyset';
}
className = _iais.Protocol().getClassNameForObject(data);
if (className != null) {
@ -127,6 +198,12 @@ class Protocol extends _is.DatabaseSerializationManager {
? className
: 'serverpod_auth_idp.$className';
}
className = _izehhkf5.Protocol().getClassNameForObject(data);
if (className != null) {
return className.contains('.')
? className
: 'serverpod_offline_sync.$className';
}
className = _iacs.Protocol().getClassNameForObject(data);
if (className != null) {
return className.contains('.')
@ -152,10 +229,17 @@ class Protocol extends _is.DatabaseSerializationManager {
if (dataClassName == 'NotFoundException') {
return deserialize<_i8oee73b.NotFoundException>(data['data']);
}
if (dataClassName == 'Studyset') {
return deserialize<_ikbclmae.Studyset>(data['data']);
}
if (dataClassName.startsWith('serverpod_auth_idp.')) {
data['className'] = dataClassName.substring(19);
return _iais.Protocol().deserializeByClassName(data);
}
if (dataClassName.startsWith('serverpod_offline_sync.')) {
data['className'] = dataClassName.substring(23);
return _izehhkf5.Protocol().deserializeByClassName(data);
}
if (dataClassName.startsWith('serverpod_auth_core.')) {
data['className'] = dataClassName.substring(20);
return _iacs.Protocol().deserializeByClassName(data);
@ -169,6 +253,7 @@ class Protocol extends _is.DatabaseSerializationManager {
void _registerHostProtocols() {
_iais.Protocol().registerHostProtocol('halkyon_learn', this);
_izehhkf5.Protocol().registerHostProtocol('halkyon_learn', this);
_iacs.Protocol().registerHostProtocol('halkyon_learn', this);
}
@ -180,6 +265,12 @@ class Protocol extends _is.DatabaseSerializationManager {
return table;
}
}
{
var table = _izehhkf5.Protocol().getTableForType(t);
if (table != null) {
return table;
}
}
{
var table = _iacs.Protocol().getTableForType(t);
if (table != null) {
@ -192,6 +283,10 @@ class Protocol extends _is.DatabaseSerializationManager {
return table;
}
}
switch (t) {
case _ikbclmae.Studyset:
return _ikbclmae.Studyset.t;
}
return null;
}
@ -214,6 +309,9 @@ class Protocol extends _is.DatabaseSerializationManager {
try {
return _iais.Protocol().mapRecordToJson(record);
} catch (_) {}
try {
return _izehhkf5.Protocol().mapRecordToJson(record);
} catch (_) {}
try {
return _iacs.Protocol().mapRecordToJson(record);
} catch (_) {}

24
halkyon_learn_server/lib/src/generated/serverpod.dart
View file

@ -12,8 +12,11 @@
// ignore_for_file: no_leading_underscores_for_library_prefixes
import 'dart:io' as _idi;
import 'package:serverpod/serverpod.dart' as _is;
import 'package:serverpod_offline_sync_server/serverpod_offline_sync_server.dart'
as _izehhkf5;
import 'endpoints.dart' as _iavctuc6;
import 'protocol.dart' as _il2as5qe;
import 'sync_tables.dart' as _ii3f3u05;
export 'package:serverpod/serverpod.dart' hide Serverpod;
/// The Serverpod server for this project.
@ -25,6 +28,10 @@ export 'package:serverpod/serverpod.dart' hide Serverpod;
/// ```dart
/// final pod = Serverpod(args);
/// ```
///
/// The `serverpod_offline_sync` engine is initialized with the tables
/// declared with `database: sync`, wrapping any provided
/// [databaseInterceptor] with `offlineSyncDatabaseInterceptor`.
class Serverpod extends _is.Serverpod {
Serverpod(
List<String> args, {
@ -55,6 +62,19 @@ class Serverpod extends _is.Serverpod {
securityContextConfig: securityContextConfig,
experimentalFeatures: experimentalFeatures,
runtimeParametersBuilder: runtimeParametersBuilder,
databaseInterceptor: databaseInterceptor,
);
databaseInterceptor:
(
session,
inner,
) => _izehhkf5.offlineSyncDatabaseInterceptor(
session,
databaseInterceptor?.call(
session,
inner,
) ??
inner,
),
) {
initializeOfflineSync(syncTables: _ii3f3u05.syncTables);
}
}

671
halkyon_learn_server/lib/src/generated/studyset/studyset.dart Normal file
View file

@ -0,0 +1,671 @@
/* 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 studyset: the cards, notes and paths that belong together; what people study and
/// share. Synced between a person's devices; its space owns it, so it has no owner column.
///
/// Only the envelope is a column: the content (title, description, …) lives in the
/// payload, so a new content field changes the payload's schema version instead of this
/// synced table, and older app versions keep syncing (ADR 0002, rule 3).
abstract class Studyset
implements _is.TableRow<_is.UuidValue?>, _is.ProtocolSerialization {
Studyset._({
this.id,
this.spaceId,
this.keyId,
required this.payload,
this.nonce,
});
factory Studyset({
_is.UuidValue? id,
int? spaceId,
String? keyId,
required _idt.ByteData payload,
_idt.ByteData? nonce,
}) = _StudysetImpl;
factory Studyset.fromJson(Map<String, dynamic> jsonSerialization) {
return Studyset(
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 = StudysetTable();
static const db = StudysetRepository._();
@override
_is.UuidValue? id;
/// The space owning this row. Maintained by the sync engine.
int? spaceId;
/// The encryption key's id; always null, since content isn't end-to-end encrypted
/// (ADR 0002). Kept so opt-in encryption of single studysets stays possible.
String? keyId;
/// The content as UTF-8 JSON: {"schemaVersion", "title", "description"}.
_idt.ByteData payload;
/// The encryption nonce; always null, like keyId.
_idt.ByteData? nonce;
@override
_is.Table<_is.UuidValue?> get table => t;
/// Returns a shallow copy of this [Studyset]
/// with some or all fields replaced by the given arguments.
@_is.useResult
Studyset copyWith({
_is.UuidValue? id,
int? spaceId,
String? keyId,
_idt.ByteData? payload,
_idt.ByteData? nonce,
});
@override
Map<String, dynamic> toJson() {
return {
'__className__': 'Studyset',
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__': 'Studyset',
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 StudysetInclude include() {
return StudysetInclude._();
}
static StudysetIncludeList includeList({
_is.WhereExpressionBuilder<StudysetTable>? where,
int? limit,
int? offset,
_is.OrderByBuilder<StudysetTable>? orderBy,
_is.OrderByListBuilder<StudysetTable>? orderByList,
StudysetInclude? include,
}) {
return StudysetIncludeList._(
where: where,
limit: limit,
offset: offset,
orderBy: orderBy?.call(Studyset.t),
orderByList: orderByList?.call(Studyset.t),
include: include,
);
}
@override
String toString() {
return _is.SerializationManager.encode(this);
}
}
class _Undefined {}
class _StudysetImpl extends Studyset {
_StudysetImpl({
_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 [Studyset]
/// with some or all fields replaced by the given arguments.
@_is.useResult
@override
Studyset copyWith({
Object? id = _Undefined,
Object? spaceId = _Undefined,
Object? keyId = _Undefined,
_idt.ByteData? payload,
Object? nonce = _Undefined,
}) {
return Studyset(
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 StudysetUpdateTable extends _is.UpdateTable<StudysetTable> {
StudysetUpdateTable(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 StudysetTable extends _is.Table<_is.UuidValue?> {
StudysetTable({super.tableRelation}) : super(tableName: 'studyset') {
updateTable = StudysetUpdateTable(this);
spaceId = _is.ColumnInt(
'spaceId',
this,
);
keyId = _is.ColumnString(
'keyId',
this,
);
payload = _is.ColumnByteData(
'payload',
this,
);
nonce = _is.ColumnByteData(
'nonce',
this,
);
}
late final StudysetUpdateTable updateTable;
/// The space owning this row. Maintained by the sync engine.
late final _is.ColumnInt spaceId;
/// The encryption key's id; always null, since content isn't end-to-end encrypted
/// (ADR 0002). Kept so opt-in encryption of single studysets stays possible.
late final _is.ColumnString keyId;
/// The content as UTF-8 JSON: {"schemaVersion", "title", "description"}.
late final _is.ColumnByteData payload;
/// The encryption nonce; always null, like keyId.
late final _is.ColumnByteData nonce;
@override
List<_is.Column> get columns => [
id,
spaceId,
keyId,
payload,
nonce,
];
}
class StudysetInclude extends _is.IncludeObject {
StudysetInclude._();
@override
Map<String, _is.Include?> get includes => {};
@override
_is.Table<_is.UuidValue?> get table => Studyset.t;
}
class StudysetIncludeList extends _is.IncludeList {
StudysetIncludeList._({
_is.WhereExpressionBuilder<StudysetTable>? where,
super.limit,
super.offset,
super.orderBy,
super.orderByList,
super.include,
}) {
super.where = where?.call(Studyset.t);
}
@override
Map<String, _is.Include?> get includes => include?.includes ?? {};
@override
_is.Table<_is.UuidValue?> get table => Studyset.t;
}
class StudysetRepository {
const StudysetRepository._();
/// Returns a list of [Studyset]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<Studyset>> find(
_is.DatabaseSession session, {
_is.WhereExpressionBuilder<StudysetTable>? where,
int? limit,
int? offset,
_is.OrderByBuilder<StudysetTable>? orderBy,
_is.OrderByListBuilder<StudysetTable>? orderByList,
_is.Transaction? transaction,
_is.LockMode? lockMode,
_is.LockBehavior? lockBehavior,
}) async {
return session.db.find<Studyset>(
where: where?.call(Studyset.t),
orderBy: orderBy?.call(Studyset.t),
orderByList: orderByList?.call(Studyset.t),
limit: limit,
offset: offset,
transaction: transaction,
lockMode: lockMode,
lockBehavior: lockBehavior,
);
}
/// Returns the first matching [Studyset] 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<Studyset?> findFirstRow(
_is.DatabaseSession session, {
_is.WhereExpressionBuilder<StudysetTable>? where,
int? offset,
_is.OrderByBuilder<StudysetTable>? orderBy,
_is.OrderByListBuilder<StudysetTable>? orderByList,
_is.Transaction? transaction,
_is.LockMode? lockMode,
_is.LockBehavior? lockBehavior,
}) async {
return session.db.findFirstRow<Studyset>(
where: where?.call(Studyset.t),
orderBy: orderBy?.call(Studyset.t),
orderByList: orderByList?.call(Studyset.t),
offset: offset,
transaction: transaction,
lockMode: lockMode,
lockBehavior: lockBehavior,
);
}
/// Finds a single [Studyset] by its [id] or null if no such row exists.
Future<Studyset?> findById(
_is.DatabaseSession session,
_is.UuidValue id, {
_is.Transaction? transaction,
_is.LockMode? lockMode,
_is.LockBehavior? lockBehavior,
}) async {
return session.db.findById<Studyset>(
id,
transaction: transaction,
lockMode: lockMode,
lockBehavior: lockBehavior,
);
}
/// Inserts all [Studyset]s in the list and returns the inserted rows.
///
/// The returned [Studyset]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<Studyset>> insert(
_is.DatabaseSession session,
List<Studyset> rows, {
_is.Transaction? transaction,
bool ignoreConflicts = false,
bool noReturn = false,
}) async {
return session.db.insert<Studyset>(
rows,
transaction: transaction,
ignoreConflicts: ignoreConflicts,
noReturn: noReturn,
);
}
/// Inserts a single [Studyset] and returns the inserted row.
///
/// The returned [Studyset] will have its `id` field set.
Future<Studyset> insertRow(
_is.DatabaseSession session,
Studyset row, {
_is.Transaction? transaction,
}) async {
return session.db.insertRow<Studyset>(
row,
transaction: transaction,
);
}
/// Upserts all [Studyset]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 [Studyset]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<Studyset>> upsert(
_is.DatabaseSession session,
List<Studyset> rows, {
required _is.ColumnSelections<StudysetTable> conflictColumns,
_is.ColumnSelections<StudysetTable>? updateColumns,
_is.WhereExpressionBuilder<StudysetTable>? updateWhere,
_is.Transaction? transaction,
bool noReturn = false,
}) async {
return session.db.upsert<Studyset>(
rows,
conflictColumns: conflictColumns(Studyset.t),
updateColumns: updateColumns?.call(Studyset.t),
updateWhere: updateWhere?.call(Studyset.t),
transaction: transaction,
noReturn: noReturn,
);
}
/// Upserts a single [Studyset] 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 [Studyset] will have its `id` field set.
Future<Studyset?> upsertRow(
_is.DatabaseSession session,
Studyset row, {
required _is.ColumnSelections<StudysetTable> conflictColumns,
_is.ColumnSelections<StudysetTable>? updateColumns,
_is.WhereExpressionBuilder<StudysetTable>? updateWhere,
_is.Transaction? transaction,
}) async {
return session.db.upsertRow<Studyset>(
row,
conflictColumns: conflictColumns(Studyset.t),
updateColumns: updateColumns?.call(Studyset.t),
updateWhere: updateWhere?.call(Studyset.t),
transaction: transaction,
);
}
/// Updates all [Studyset]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<Studyset>> update(
_is.DatabaseSession session,
List<Studyset> rows, {
_is.ColumnSelections<StudysetTable>? columns,
_is.Transaction? transaction,
bool noReturn = false,
}) async {
return session.db.update<Studyset>(
rows,
columns: columns?.call(Studyset.t),
transaction: transaction,
noReturn: noReturn,
);
}
/// Updates a single [Studyset]. 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<Studyset> updateRow(
_is.DatabaseSession session,
Studyset row, {
_is.ColumnSelections<StudysetTable>? columns,
_is.Transaction? transaction,
}) async {
return session.db.updateRow<Studyset>(
row,
columns: columns?.call(Studyset.t),
transaction: transaction,
);
}
/// Updates a single [Studyset] by its [id] with the specified [columnValues].
/// Returns the updated row or null if no row with the given id exists.
Future<Studyset?> updateById(
_is.DatabaseSession session,
_is.UuidValue id, {
required _is.ColumnValueListBuilder<StudysetUpdateTable> columnValues,
_is.Transaction? transaction,
}) async {
return session.db.updateById<Studyset>(
id,
columnValues: columnValues(Studyset.t.updateTable),
transaction: transaction,
);
}
/// Updates all [Studyset]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<Studyset>> updateWhere(
_is.DatabaseSession session, {
required _is.ColumnValueListBuilder<StudysetUpdateTable> columnValues,
required _is.WhereExpressionBuilder<StudysetTable> where,
int? limit,
int? offset,
_is.OrderByBuilder<StudysetTable>? orderBy,
_is.OrderByListBuilder<StudysetTable>? orderByList,
_is.Transaction? transaction,
bool noReturn = false,
}) async {
return session.db.updateWhere<Studyset>(
columnValues: columnValues(Studyset.t.updateTable),
where: where(Studyset.t),
limit: limit,
offset: offset,
orderBy: orderBy?.call(Studyset.t),
orderByList: orderByList?.call(Studyset.t),
transaction: transaction,
noReturn: noReturn,
);
}
/// Deletes all [Studyset]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<Studyset>> delete(
_is.DatabaseSession session,
List<Studyset> rows, {
_is.OrderByBuilder<StudysetTable>? orderBy,
_is.OrderByListBuilder<StudysetTable>? orderByList,
_is.Transaction? transaction,
bool noReturn = false,
}) async {
return session.db.delete<Studyset>(
rows,
orderBy: orderBy?.call(Studyset.t),
orderByList: orderByList?.call(Studyset.t),
transaction: transaction,
noReturn: noReturn,
);
}
/// Deletes a single [Studyset].
Future<Studyset> deleteRow(
_is.DatabaseSession session,
Studyset row, {
_is.Transaction? transaction,
}) async {
return session.db.deleteRow<Studyset>(
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<Studyset>> deleteWhere(
_is.DatabaseSession session, {
required _is.WhereExpressionBuilder<StudysetTable> where,
_is.OrderByBuilder<StudysetTable>? orderBy,
_is.OrderByListBuilder<StudysetTable>? orderByList,
_is.Transaction? transaction,
bool noReturn = false,
}) async {
return session.db.deleteWhere<Studyset>(
where: where(Studyset.t),
orderBy: orderBy?.call(Studyset.t),
orderByList: orderByList?.call(Studyset.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<StudysetTable>? where,
int? limit,
_is.Transaction? transaction,
}) async {
return session.db.count<Studyset>(
where: where?.call(Studyset.t),
limit: limit,
transaction: transaction,
);
}
/// Acquires row-level locks on [Studyset] rows matching the [where] expression.
Future<void> lockRows(
_is.DatabaseSession session, {
required _is.WhereExpressionBuilder<StudysetTable> where,
required _is.LockMode lockMode,
required _is.Transaction transaction,
_is.LockBehavior lockBehavior = _is.LockBehavior.wait,
}) async {
return session.db.lockRows<Studyset>(
where: where(Studyset.t),
lockMode: lockMode,
lockBehavior: lockBehavior,
transaction: transaction,
);
}
}

19
halkyon_learn_server/lib/src/generated/sync_tables.dart Normal file
View file

@ -0,0 +1,19 @@
/* 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 'package:serverpod/serverpod.dart' as _is;
import 'studyset/studyset.dart' as _ikbclmae;
/// The tables synchronized between client and server by the
/// `serverpod_offline_sync` package, including the ones owned by modules and
/// shared packages.
final List<_is.Table> syncTables = [_ikbclmae.Studyset.t];

17
halkyon_learn_server/lib/src/studyset/studyset.spy.yaml Normal file
View file

@ -0,0 +1,17 @@
### A studyset: the cards, notes and paths that belong together; what people study and
### share. Synced between a person's devices; its space owns it, so it has no owner column.
###
### Only the envelope is a column: the content (title, description, …) lives in the
### payload, so a new content field changes the payload's schema version instead of this
### synced table, and older app versions keep syncing (ADR 0002, rule 3).
class: Studyset
table: studyset
database: sync
fields:
### The encryption key's id; always null, since content isn't end-to-end encrypted
### (ADR 0002). Kept so opt-in encryption of single studysets stays possible.
keyId: String?
### The content as UTF-8 JSON: {"schemaVersion", "title", "description"}.
payload: ByteData
### The encryption nonce; always null, like keyId.
nonce: ByteData?

1
halkyon_learn_server/pubspec.yaml
View file

@ -11,6 +11,7 @@ resolution: workspace
dependencies:
serverpod: 4.0.2
serverpod_auth_idp_server: 4.0.2
serverpod_offline_sync_server: 0.0.8
dev_dependencies:
serverpod_test: 4.0.2
test: ^1.25.5

31
halkyon_learn_server/test/integration/test_tools/serverpod_test_tools.dart
View file

@ -13,7 +13,6 @@
// ignore_for_file: no_leading_underscores_for_library_prefixes
import 'dart:async' as _ida;
import 'dart:io' as _idi;
import 'package:halkyon_learn_server/src/generated/auth/device.dart'
as _ipdmo8cq;
import 'package:serverpod/serverpod.dart' as _is;
@ -199,10 +198,12 @@ class _AnonymousIdpEndpoint {
parameters: _ist.testObjectToJson({'token': token}),
serializationManager: _serializationManager,
);
var _localReturnValue = await (_localCallContext.method.call(
_localUniqueSession,
_localCallContext.arguments,
) as _ida.Future<_iacs.AuthSuccess>);
var _localReturnValue =
await (_localCallContext.method.call(
_localUniqueSession,
_localCallContext.arguments,
)
as _ida.Future<_iacs.AuthSuccess>);
return _localReturnValue;
} finally {
await _localUniqueSession.close();
@ -238,10 +239,12 @@ class _DevicesEndpoint {
parameters: _ist.testObjectToJson({}),
serializationManager: _serializationManager,
);
var _localReturnValue = await (_localCallContext.method.call(
_localUniqueSession,
_localCallContext.arguments,
) as _ida.Future<List<_ipdmo8cq.Device>>);
var _localReturnValue =
await (_localCallContext.method.call(
_localUniqueSession,
_localCallContext.arguments,
)
as _ida.Future<List<_ipdmo8cq.Device>>);
return _localReturnValue;
} finally {
await _localUniqueSession.close();
@ -267,10 +270,12 @@ class _DevicesEndpoint {
parameters: _ist.testObjectToJson({'sessionId': sessionId}),
serializationManager: _serializationManager,
);
var _localReturnValue = await (_localCallContext.method.call(
_localUniqueSession,
_localCallContext.arguments,
) as _ida.Future<void>);
var _localReturnValue =
await (_localCallContext.method.call(
_localUniqueSession,
_localCallContext.arguments,
)
as _ida.Future<void>);
return _localReturnValue;
} finally {
await _localUniqueSession.close();