From 325513b75aadda64a930c99e5734c8c6ae1ef6ac Mon Sep 17 00:00:00 2001 From: Sun Cao Date: Fri, 13 Nov 2026 17:35:11 +0000 Subject: [PATCH] Share a table from a start version A share can record the first version of a table that recipients may read, set with startVersion on the data object that adds the table, and kept in a new column of the shared objects. Reading an earlier version is refused with 403 PERMISSION_DENIED "You can only query table data since version N." whether the version is asked for directly, resolved from a timestamp, or the start of a change range. A table without a start version has no limit. Co-authored-by: Isaac Signed-off-by: Sun Cao --- .../asset/SharedDataObjectEntity.java | 15 ++++ .../asset/SharedDataObjectStore.java | 4 +- .../asset/table/ProtocolTables.java | 32 ++++++--- .../asset/table/delta/DeltaSnapshots.java | 12 +++- .../table/delta/DeltaTableMetadataReader.java | 3 +- .../table/delta/DeltaTableQueryReader.java | 13 ++-- .../io/opensharing/share/ShareResponse.java | 12 +++- .../io/opensharing/share/ShareService.java | 11 ++- .../opensharing/share/UpdateShareRequest.java | 5 +- .../delta/DeltaTableQueryReaderTest.java | 71 +++++++++++++++++++ .../V2__add_shared_object_start_version.sql | 1 + .../V2__add_shared_object_start_version.sql | 1 + .../V2__add_shared_object_start_version.sql | 1 + .../protocol/ProtocolApiSupport.java | 15 ++++ .../ProtocolTableStartVersionTest.java | 43 +++++++++++ 15 files changed, 214 insertions(+), 25 deletions(-) create mode 100644 server/opensharing-server/src/main/resources/db/migration/h2/V2__add_shared_object_start_version.sql create mode 100644 server/opensharing-server/src/main/resources/db/migration/mysql/V2__add_shared_object_start_version.sql create mode 100644 server/opensharing-server/src/main/resources/db/migration/postgresql/V2__add_shared_object_start_version.sql create mode 100644 server/opensharing-server/src/test/java/io/opensharing/protocol/ProtocolTableStartVersionTest.java diff --git a/server/opensharing-server-core/src/main/java/io/opensharing/asset/SharedDataObjectEntity.java b/server/opensharing-server-core/src/main/java/io/opensharing/asset/SharedDataObjectEntity.java index 013650494..3a1d9006e 100644 --- a/server/opensharing-server-core/src/main/java/io/opensharing/asset/SharedDataObjectEntity.java +++ b/server/opensharing-server-core/src/main/java/io/opensharing/asset/SharedDataObjectEntity.java @@ -66,6 +66,13 @@ public class SharedDataObjectEntity extends BaseEntity { @Column(name = "auxiliary_locations", length = 8192) private String auxiliaryLocations; + /** + * The first version of a table that recipients may read, or null for all of them. A read that + * resolves to an earlier version is refused. + */ + @Column(name = "start_version") + private Long startVersion; + /** Lowercase schema name recipients see. */ @Column(name = "shared_as_schema", nullable = false, length = 255) private String sharedAsSchema; @@ -131,6 +138,14 @@ public void setAuxiliaryLocations(List auxiliaryLocations) { auxiliaryLocations.isEmpty() ? null : String.join("\n", auxiliaryLocations); } + public Long getStartVersion() { + return startVersion; + } + + public void setStartVersion(Long startVersion) { + this.startVersion = startVersion; + } + public String getSharedAsSchema() { return sharedAsSchema; } diff --git a/server/opensharing-server-core/src/main/java/io/opensharing/asset/SharedDataObjectStore.java b/server/opensharing-server-core/src/main/java/io/opensharing/asset/SharedDataObjectStore.java index 399e93fa1..530ee6c0a 100644 --- a/server/opensharing-server-core/src/main/java/io/opensharing/asset/SharedDataObjectStore.java +++ b/server/opensharing-server-core/src/main/java/io/opensharing/asset/SharedDataObjectStore.java @@ -31,7 +31,8 @@ public SharedDataObjectEntity add( AssetType type, ResolvedAsset resolved, String sharedAsSchema, - String sharedAsTable) { + String sharedAsTable, + Long startVersion) { if (findByAlias(em, share, sharedAsSchema, sharedAsTable).isPresent()) { throw ApiException.alreadyExists( "alias '" @@ -61,6 +62,7 @@ public SharedDataObjectEntity add( } object.setSharedAsSchema(sharedAsSchema); object.setSharedAsTable(sharedAsTable); + object.setStartVersion(startVersion); em.persist(object); return object; } diff --git a/server/opensharing-server-core/src/main/java/io/opensharing/asset/table/ProtocolTables.java b/server/opensharing-server-core/src/main/java/io/opensharing/asset/table/ProtocolTables.java index 4f7ef8bee..6b3b12922 100644 --- a/server/opensharing-server-core/src/main/java/io/opensharing/asset/table/ProtocolTables.java +++ b/server/opensharing-server-core/src/main/java/io/opensharing/asset/table/ProtocolTables.java @@ -144,8 +144,9 @@ public DeltaTableMetadataReader.Result metadata( String capabilities) { ShareEntity share = protocolShares.requireGranted(recipient, shareName); Instant asOf = parseTimestamp(timestamp); - ResolvedAsset table = findTable(share, schemaAlias, tableAlias).catalogTable(); - return metadataReader.read(table, version, asOf, owner(share), capabilities); + SharedTable table = findTable(share, schemaAlias, tableAlias); + return metadataReader.read( + table.catalogTable(), table.startVersion(), version, asOf, owner(share), capabilities); } /** @@ -203,9 +204,9 @@ public void query( DeltaTableQueryReader.ResponseOptions options, DeltaTableQueryReader.ResponseSink sink) { ShareEntity share = protocolShares.requireGranted(recipient, shareName); + SharedTable sharedTable = findTable(share, schemaAlias, tableAlias); ResolvedAsset catalogTable = - requireUrlAccess( - findTable(share, schemaAlias, tableAlias).catalogTable(), schemaAlias, tableAlias); + requireUrlAccess(sharedTable.catalogTable(), schemaAlias, tableAlias); QueryTableRequest body = request == null ? QueryTableRequest.EMPTY : request; int selectors = (body.version() != null ? 1 : 0) @@ -216,7 +217,7 @@ public void query( "Please only provide one of: version,timestamp,startingVersion."); } if (body.startingVersion() != null || body.endingVersion() != null) { - queryChanges(body, catalogTable, share, options, sink); + queryChanges(body, catalogTable, sharedTable.startVersion(), share, options, sink); return; } boolean historical = body.version() != null || body.timestamp() != null; @@ -234,6 +235,7 @@ public void query( } queryReader.read( catalogTable, + sharedTable.startVersion(), owner(share), options, sink, @@ -260,12 +262,13 @@ public void changes( DeltaTableQueryReader.ResponseOptions options, DeltaTableQueryReader.ResponseSink sink) { ShareEntity share = protocolShares.requireGranted(recipient, shareName); + SharedTable sharedTable = findTable(share, schemaAlias, tableAlias); ResolvedAsset catalogTable = - requireUrlAccess( - findTable(share, schemaAlias, tableAlias).catalogTable(), schemaAlias, tableAlias); + requireUrlAccess(sharedTable.catalogTable(), schemaAlias, tableAlias); try { queryReader.readChangeDataFeed( catalogTable, + sharedTable.startVersion(), owner(share), options, sink, @@ -308,6 +311,7 @@ private static ResolvedAsset requireUrlAccess( private void queryChanges( QueryTableRequest body, ResolvedAsset table, + long tableStartVersion, ShareEntity share, DeltaTableQueryReader.ResponseOptions options, DeltaTableQueryReader.ResponseSink sink) { @@ -333,6 +337,7 @@ private void queryChanges( } queryReader.readChanges( table, + tableStartVersion, owner(share), options, sink, @@ -359,8 +364,13 @@ private SharedTable findTable(ShareEntity share, String schemaAlias, String tabl if (sharedTable.isPresent()) { ResolvedAsset catalogTable = resolveSharedAsset(share, sharedTable.get()); if (catalogTable != null) { + Long startVersion = sharedTable.get().getStartVersion(); return new SharedTable( - schemaAlias, tableAlias, sharedTable.get().getSourceAssetId(), catalogTable); + schemaAlias, + tableAlias, + sharedTable.get().getSourceAssetId(), + catalogTable, + startVersion == null ? 0 : startVersion); } } // Recipients see aliases only, so the catalog's own not-found message must not reach them. @@ -415,7 +425,11 @@ private static Instant parseTimestamp(String value) { /** A table of the share, with the catalog table it resolved to. */ private record SharedTable( - String schemaAlias, String tableAlias, String tableId, ResolvedAsset catalogTable) {} + String schemaAlias, + String tableAlias, + String tableId, + ResolvedAsset catalogTable, + long startVersion) {} /** The tables {@code sharedObjects} puts on the listing, by schema alias and table alias. */ private List listTables( diff --git a/server/opensharing-server-core/src/main/java/io/opensharing/asset/table/delta/DeltaSnapshots.java b/server/opensharing-server-core/src/main/java/io/opensharing/asset/table/delta/DeltaSnapshots.java index 4dbeb8f9b..5f76db1f1 100644 --- a/server/opensharing-server-core/src/main/java/io/opensharing/asset/table/delta/DeltaSnapshots.java +++ b/server/opensharing-server-core/src/main/java/io/opensharing/asset/table/delta/DeltaSnapshots.java @@ -13,7 +13,17 @@ final class DeltaSnapshots { private DeltaSnapshots() {} - static Snapshot open(DeltaKernel.Session session, Long version, Instant timestamp) { + static Snapshot open( + DeltaKernel.Session session, Long version, Instant timestamp, long startVersion) { + Snapshot snapshot = openAt(session, version, timestamp); + if (snapshot.getVersion() < startVersion) { + throw ApiException.permissionDenied( + "You can only query table data since version " + startVersion + "."); + } + return snapshot; + } + + private static Snapshot openAt(DeltaKernel.Session session, Long version, Instant timestamp) { Snapshot latest = DeltaKernel.latestSnapshot(session.table(), session.engine()); if (version == null && timestamp == null) { return latest; diff --git a/server/opensharing-server-core/src/main/java/io/opensharing/asset/table/delta/DeltaTableMetadataReader.java b/server/opensharing-server-core/src/main/java/io/opensharing/asset/table/delta/DeltaTableMetadataReader.java index 93cf6a8a2..a87c67466 100644 --- a/server/opensharing-server-core/src/main/java/io/opensharing/asset/table/delta/DeltaTableMetadataReader.java +++ b/server/opensharing-server-core/src/main/java/io/opensharing/asset/table/delta/DeltaTableMetadataReader.java @@ -25,6 +25,7 @@ public DeltaTableMetadataReader(DeltaKernel kernel) { public Result read( ResolvedAsset table, + long startVersion, Long version, Instant timestamp, AuthContext auth, @@ -33,7 +34,7 @@ public Result read( throw ApiException.invalidParameter("version and timestamp are mutually exclusive"); } try (DeltaKernel.Session session = kernel.open(table, auth)) { - Snapshot snapshot = DeltaSnapshots.open(session, version, timestamp); + Snapshot snapshot = DeltaSnapshots.open(session, version, timestamp, startVersion); SnapshotImpl impl = (SnapshotImpl) snapshot; boolean historical = version != null || timestamp != null; ResponseFormat format = diff --git a/server/opensharing-server-core/src/main/java/io/opensharing/asset/table/delta/DeltaTableQueryReader.java b/server/opensharing-server-core/src/main/java/io/opensharing/asset/table/delta/DeltaTableQueryReader.java index 9ac41a074..8c38d739f 100644 --- a/server/opensharing-server-core/src/main/java/io/opensharing/asset/table/delta/DeltaTableQueryReader.java +++ b/server/opensharing-server-core/src/main/java/io/opensharing/asset/table/delta/DeltaTableQueryReader.java @@ -119,6 +119,7 @@ public DeltaTableQueryReader(DeltaKernel kernel, UrlSigners signers) { */ public void read( ResolvedAsset table, + long startVersion, AuthContext auth, ResponseOptions options, ResponseSink sink, @@ -140,7 +141,7 @@ public void read( try (DeltaKernel.Session session = kernel.open(table, auth, URL_TTL); ResponseWriter out = new ResponseWriter(session, table, options, sink)) { - Snapshot snapshot = DeltaSnapshots.open(session, version, timestamp); + Snapshot snapshot = DeltaSnapshots.open(session, version, timestamp, startVersion); SnapshotImpl impl = (SnapshotImpl) snapshot; DeltaSharingCapabilities.requireColumnMappingSupport( options.capabilities(), impl.getMetadata().getConfiguration(), snapshot.getVersion()); @@ -196,6 +197,7 @@ public void read( */ public void readChanges( ResolvedAsset table, + long startVersion, AuthContext auth, ResponseOptions options, ResponseSink sink, @@ -203,7 +205,7 @@ public void readChanges( Long endingVersion, boolean includeHistoricalProtocol) { try (DeltaKernel.Session session = kernel.open(table, auth, URL_TTL)) { - long latest = DeltaSnapshots.open(session, null, null).getVersion(); + long latest = DeltaSnapshots.open(session, null, null, startVersion).getVersion(); requireAtMostLatest("startingVersion", startingVersion, latest); if (endingVersion != null) { requireAtMostLatest("endingVersion", endingVersion, latest); @@ -211,7 +213,7 @@ public void readChanges( changes( session, table, - (SnapshotImpl) DeltaSnapshots.open(session, startingVersion, null), + (SnapshotImpl) DeltaSnapshots.open(session, startingVersion, null, startVersion), ChangeRange.dataChanges( startingVersion, endingVersion == null ? latest : endingVersion, @@ -230,6 +232,7 @@ public void readChanges( */ public void readChangeDataFeed( ResolvedAsset table, + long startVersion, AuthContext auth, ResponseOptions options, ResponseSink sink, @@ -240,7 +243,7 @@ public void readChangeDataFeed( boolean includeHistoricalMetadata, boolean includeHistoricalProtocol) { try (DeltaKernel.Session session = kernel.open(table, auth, URL_TTL)) { - SnapshotImpl latest = (SnapshotImpl) DeltaSnapshots.open(session, null, null); + SnapshotImpl latest = (SnapshotImpl) DeltaSnapshots.open(session, null, null, startVersion); TableImpl delta = (TableImpl) session.table(); if (endingTimestamp != null) { requireEndingTimestampAtMostLatest(endingTimestamp, latest, session); @@ -268,7 +271,7 @@ public void readChangeDataFeed( "endingVersion " + end + " is before startingVersion " + start); } long resolvedEnd = end == null ? latest.getVersion() : Math.min(end, latest.getVersion()); - SnapshotImpl first = (SnapshotImpl) DeltaSnapshots.open(session, start, null); + SnapshotImpl first = (SnapshotImpl) DeltaSnapshots.open(session, start, null, startVersion); if (!changeDataFeedEnabled(first.getMetadata())) { throw new ChangeDataNotRecordedException(start); } diff --git a/server/opensharing-server-core/src/main/java/io/opensharing/share/ShareResponse.java b/server/opensharing-server-core/src/main/java/io/opensharing/share/ShareResponse.java index d31df8662..dc41fa088 100644 --- a/server/opensharing-server-core/src/main/java/io/opensharing/share/ShareResponse.java +++ b/server/opensharing-server-core/src/main/java/io/opensharing/share/ShareResponse.java @@ -17,7 +17,8 @@ * "displayName": "", * "comment": "", * "properties": {"": ""}, - * "objects": [{"name": "", "type": "TABLE", "sharedAs": ""}], + * "objects": [{"name": "", "type": "TABLE", "sharedAs": "", + * "startVersion": 1}], * "ownerId": "" * } * } @@ -55,11 +56,16 @@ public static ShareResponse from(ShareEntity share, List } /** A catalog asset included in a share, with the alias recipients see it under. */ - public record SharedDataObjectResponse(String name, AssetType type, String sharedAs) { + @JsonInclude(JsonInclude.Include.NON_NULL) + public record SharedDataObjectResponse( + String name, AssetType type, String sharedAs, Long startVersion) { static SharedDataObjectResponse from(SharedDataObjectEntity object) { return new SharedDataObjectResponse( - object.getFullName(), object.getType(), object.getSharedAs()); + object.getFullName(), + object.getType(), + object.getSharedAs(), + object.getStartVersion()); } } } diff --git a/server/opensharing-server-core/src/main/java/io/opensharing/share/ShareService.java b/server/opensharing-server-core/src/main/java/io/opensharing/share/ShareService.java index 18dfee15b..32f7ccffa 100644 --- a/server/opensharing-server-core/src/main/java/io/opensharing/share/ShareService.java +++ b/server/opensharing-server-core/src/main/java/io/opensharing/share/ShareService.java @@ -169,7 +169,8 @@ public ShareResponse update(UserContext user, String share, UpdateShareRequest r addition.type(), addition.resolved(), addition.alias().schema(), - addition.alias().table()); + addition.alias().table(), + addition.startVersion()); } shares.update(entity, displayName, comment, properties, newOwnerId); return entity; @@ -302,7 +303,10 @@ private Addition addition(UserContext user, UpdateShareRequest.DataObject dataOb throw new CatalogException( "catalog resolved '" + name + "' as " + resolved.type() + " instead of " + type); } - return new Addition(name, type, resolved, alias); + if (dataObject.startVersion() != null && dataObject.startVersion() < 0) { + throw ApiException.invalidParameter("dataObject.startVersion must not be negative"); + } + return new Addition(name, type, resolved, alias, dataObject.startVersion()); } // Removes by alias when sharedAs is given, otherwise by catalog name. @@ -391,7 +395,8 @@ private static String requireMaxLength(String value, int maxLength, String field private record Alias(String schema, String table) {} - private record Addition(String name, AssetType type, ResolvedAsset resolved, Alias alias) {} + private record Addition( + String name, AssetType type, ResolvedAsset resolved, Alias alias, Long startVersion) {} private record RecipientChange( RecipientEntity recipient, UpdateSharePermissionsRequest.Change change) {} diff --git a/server/opensharing-server-core/src/main/java/io/opensharing/share/UpdateShareRequest.java b/server/opensharing-server-core/src/main/java/io/opensharing/share/UpdateShareRequest.java index 26869e462..3a686eea8 100644 --- a/server/opensharing-server-core/src/main/java/io/opensharing/share/UpdateShareRequest.java +++ b/server/opensharing-server-core/src/main/java/io/opensharing/share/UpdateShareRequest.java @@ -30,9 +30,10 @@ public record Update(Action action, DataObject dataObject) {} /** * A catalog table. {@code name} is the full catalog name; {@code sharedAs} is the alias * recipients see, {@code schema.table}, and defaults to {@code name} without its catalog. A - * remove needs {@code name} or {@code sharedAs}. + * remove needs {@code name} or {@code sharedAs}. {@code startVersion}, if set, is the first + * version of the table that recipients may read. */ - public record DataObject(String name, AssetType type, String sharedAs) {} + public record DataObject(String name, AssetType type, String sharedAs, Long startVersion) {} public enum Action { ADD, diff --git a/server/opensharing-server-core/src/test/java/io/opensharing/asset/table/delta/DeltaTableQueryReaderTest.java b/server/opensharing-server-core/src/test/java/io/opensharing/asset/table/delta/DeltaTableQueryReaderTest.java index 1270d0ee1..2288246bc 100644 --- a/server/opensharing-server-core/src/test/java/io/opensharing/asset/table/delta/DeltaTableQueryReaderTest.java +++ b/server/opensharing-server-core/src/test/java/io/opensharing/asset/table/delta/DeltaTableQueryReaderTest.java @@ -165,6 +165,71 @@ void startingVersionReturnsDataChangeFilesAndHistoricalMetadata() throws IOExcep assertThrows(ApiException.class, () -> changes(1L, null, null, false)); } + @Test + void refusesVersionsBeforeTheTablesStartVersion() throws IOException { + writeChanges(); + for (int version = 0; version <= 4; version++) { + Files.setLastModifiedTime( + dir.resolve("_delta_log/%020d.json".formatted(version)), + FileTime.fromMillis((version + 1) * 1000L)); + } + DeltaTableQueryReader.ResponseOptions options = + new DeltaTableQueryReader.ResponseOptions(null, null, false); + String refused = "You can only query table data since version 2."; + // The latest snapshot is at the start version or later, so it is served. + reader.read(table, 2, null, options, new Lines(), null, null, null, false, null, null); + // A version, a timestamp resolving to a version, and a change range starting before it are not. + ApiException byVersion = + assertThrows( + ApiException.class, + () -> + reader.read(table, 2, null, options, new Lines(), 1L, null, null, false, null, null)); + assertEquals(403, byVersion.getStatus()); + assertEquals(refused, byVersion.getMessage()); + assertEquals( + refused, + assertThrows( + ApiException.class, + () -> + reader.read( + table, + 2, + null, + options, + new Lines(), + null, + Instant.ofEpochMilli(1500), + null, + false, + null, + null)) + .getMessage()); + assertEquals( + refused, + assertThrows( + ApiException.class, + () -> reader.readChanges(table, 2, null, options, new Lines(), 1L, null, false)) + .getMessage()); + reader.readChanges( + table, + 2, + null, + new DeltaTableQueryReader.ResponseOptions( + "responseformat=delta;readerfeatures=deletionvectors", null, false), + new Lines(), + 2L, + null, + false); + assertEquals( + refused, + assertThrows( + ApiException.class, + () -> + reader.readChangeDataFeed( + table, 2, null, options, new Lines(), 0L, null, null, null, false, false)) + .getMessage()); + } + @Test void includeHistoricalProtocolAddsLaterProtocolsToDeltaResponses() throws IOException { writeChanges(); @@ -205,6 +270,7 @@ void startingVersionDecodesLogPathsButNotTheTableRoot() throws IOException { }) .readChanges( table(root), + 0, null, new DeltaTableQueryReader.ResponseOptions(null, null, false), new Lines(), @@ -289,6 +355,7 @@ private String changeDataFeedProtocol(boolean includeHistoricalMetadata) { Lines lines = new Lines(); reader.readChangeDataFeed( table, + 0, null, new DeltaTableQueryReader.ResponseOptions("responseformat=delta", null, false), lines, @@ -311,6 +378,7 @@ private List changeDataFeed( Lines lines = new Lines(); reader.readChangeDataFeed( table, + 0, null, new DeltaTableQueryReader.ResponseOptions(capabilities, null, false), lines, @@ -371,6 +439,7 @@ private List changes( Lines lines = new Lines(); reader.readChanges( table, + 0, null, new DeltaTableQueryReader.ResponseOptions(capabilities, null, false), lines, @@ -493,6 +562,7 @@ private List signedUrls(String path, String deletionVector) throws IOExc reader(root) .read( table(root), + 0, null, new DeltaTableQueryReader.ResponseOptions( "responseformat=delta;readerfeatures=deletionvectors", null, false), @@ -521,6 +591,7 @@ private String ndjson(String jsonPredicateHints, Long limitHint) { Lines lines = new Lines(); reader.read( table, + 0, null, new DeltaTableQueryReader.ResponseOptions(null, null, false), lines, diff --git a/server/opensharing-server/src/main/resources/db/migration/h2/V2__add_shared_object_start_version.sql b/server/opensharing-server/src/main/resources/db/migration/h2/V2__add_shared_object_start_version.sql new file mode 100644 index 000000000..7e98bf473 --- /dev/null +++ b/server/opensharing-server/src/main/resources/db/migration/h2/V2__add_shared_object_start_version.sql @@ -0,0 +1 @@ +alter table os_shared_data_objects add column start_version bigint; diff --git a/server/opensharing-server/src/main/resources/db/migration/mysql/V2__add_shared_object_start_version.sql b/server/opensharing-server/src/main/resources/db/migration/mysql/V2__add_shared_object_start_version.sql new file mode 100644 index 000000000..7e98bf473 --- /dev/null +++ b/server/opensharing-server/src/main/resources/db/migration/mysql/V2__add_shared_object_start_version.sql @@ -0,0 +1 @@ +alter table os_shared_data_objects add column start_version bigint; diff --git a/server/opensharing-server/src/main/resources/db/migration/postgresql/V2__add_shared_object_start_version.sql b/server/opensharing-server/src/main/resources/db/migration/postgresql/V2__add_shared_object_start_version.sql new file mode 100644 index 000000000..7e98bf473 --- /dev/null +++ b/server/opensharing-server/src/main/resources/db/migration/postgresql/V2__add_shared_object_start_version.sql @@ -0,0 +1 @@ +alter table os_shared_data_objects add column start_version bigint; diff --git a/server/opensharing-server/src/test/java/io/opensharing/protocol/ProtocolApiSupport.java b/server/opensharing-server/src/test/java/io/opensharing/protocol/ProtocolApiSupport.java index bf4e60f54..04d49dbff 100644 --- a/server/opensharing-server/src/test/java/io/opensharing/protocol/ProtocolApiSupport.java +++ b/server/opensharing-server/src/test/java/io/opensharing/protocol/ProtocolApiSupport.java @@ -66,6 +66,21 @@ protected static void addObject(String share, String type, String name, String s assertEquals(200, added.status()); } + /** + * Adds the catalog asset {@code name} of {@code type} to the share as {@code sharedAs}, readable + * from {@code startVersion} on. + */ + protected static void addObject( + String share, String type, String name, String sharedAs, long startVersion) { + String body = + "{\"updates\":[{\"action\":\"ADD\",\"dataObject\":" + + "{\"name\":\"%s\",\"type\":\"%s\",\"sharedAs\":\"%s\",\"startVersion\":%d}}]}"; + Response added = + server.patch( + PROVIDER + "/shares/" + share, ALICE, body.formatted(name, type, sharedAs, startVersion)); + assertEquals(200, added.status()); + } + /** Creates a TOKEN recipient, redeems its activation URL, and returns the bearer token. */ protected static String createAndActivateRecipient(String name) { Response created = diff --git a/server/opensharing-server/src/test/java/io/opensharing/protocol/ProtocolTableStartVersionTest.java b/server/opensharing-server/src/test/java/io/opensharing/protocol/ProtocolTableStartVersionTest.java new file mode 100644 index 000000000..eca0bcf6e --- /dev/null +++ b/server/opensharing-server/src/test/java/io/opensharing/protocol/ProtocolTableStartVersionTest.java @@ -0,0 +1,43 @@ +package io.opensharing.protocol; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import io.opensharing.TestServer.Response; +import io.opensharing.http.ErrorCodes; +import org.junit.jupiter.api.Test; + +/** A table shared from a start version refuses reads of the versions before it. */ +class ProtocolTableStartVersionTest extends LocalDeltaTableSupport { + + @Test + void refusesVersionsBeforeTheStartVersion() { + createShare("start-version"); + addObject("start-version", "TABLE", "main.hr.salaries", "hr.salaries", 2); + String bearer = createAndActivateRecipient("start-version-partner"); + grant("start-version", "start-version-partner"); + String table = PROTOCOL + "/shares/start-version/schemas/hr/tables/salaries"; + + // The latest version is at or after the start version. + assertEquals(200, server.get(table + "/metadata", bearer).status()); + assertEquals(200, server.get(table + "/metadata?version=2", bearer).status()); + + for (String before : + new String[] { + table + "/metadata?version=1", + table + "/metadata?timestamp=2024-01-01T01:30:00Z", + table + "/changes?startingVersion=0" + }) { + Response refused = server.get(before, bearer); + assertEquals(403, refused.status(), before); + assertEquals(ErrorCodes.PERMISSION_DENIED, refused.errorCode(), before); + assertTrue( + refused.text().contains("You can only query table data since version 2."), + refused.text()); + } + Response query = server.post(table + "/query", bearer, "{\"version\":0}"); + assertEquals(403, query.status(), query.text()); + Response range = server.post(table + "/query", bearer, "{\"startingVersion\":1}"); + assertEquals(403, range.status(), range.text()); + } +}