@abloatai/transaction 0.55.0 → 0.57.0

package/src/schema/roles.ts

@@ -219,6 +219,8 @@ export const groupsInputSchema = z.object({
   root: scopeSchema.optional(),
   grants: grantsRefSchema.optional(),
   roles: z.union([entityRoleSchema, z.array(entityRoleSchema)]).optional(),
+  /** Acknowledge that these groups are delivery routing, not row access. */
+  routingOnly: z.literal(true).optional(),
 });
 export type GroupsInput = z.infer<typeof groupsInputSchema>;
 
@@ -314,6 +316,57 @@ export function composeEntitySyncGroups(
   return Array.from(out);
 }
 
+/** The row fields needed to derive its durable delivery groups. */
+export interface RecordSyncGroupSpec {
+  readonly subject?: { readonly kind: string; readonly field: string };
+  readonly selfKind?: string;
+  readonly parents: readonly { readonly kind: string; readonly field: string }[];
+}
+
+/** A subject-scoped row cannot be routed safely without its declared subject. */
+export class InvalidRecordSubjectError extends Error {
+  readonly field: string;
+
+  constructor(field: string) {
+    super(`Record lacks non-empty subject field "${field}".`);
+    this.name = 'InvalidRecordSubjectError';
+    this.field = field;
+  }
+}
+
+/**
+ * Derive the exact durable delivery groups for a row.
+ *
+ * Delivery matching is OR-based, so a declared subject is an exclusive
+ * authorization route: self, parent, entity-role, writer, and transitive groups
+ * must not become alternate ways to receive the row. Additional groups are
+ * accepted here so every producer applies that rule in this one place.
+ */
+export function syncGroupsForRow(
+  spec: RecordSyncGroupSpec | undefined,
+  record: Readonly<Record<string, unknown>>,
+  additionalGroups: readonly string[] = [],
+): string[] {
+  if (spec?.subject) {
+    const value = record[spec.subject.field];
+    if (typeof value !== 'string' || value.length === 0) {
+      throw new InvalidRecordSubjectError(spec.subject.field);
+    }
+    return [syncGroup(spec.subject.kind, value)];
+  }
+
+  const groups = new Set<string>(additionalGroups);
+  if (!spec) return [...groups];
+  if (spec.selfKind && typeof record.id === 'string' && record.id.length > 0) {
+    groups.add(syncGroup(spec.selfKind, record.id));
+  }
+  for (const parent of spec.parents) {
+    const value = record[parent.field];
+    if (value) groups.add(syncGroup(parent.kind, String(value)));
+  }
+  return [...groups];
+}
+
 /**
  * Narrow a client's requested sync-group set to the groups it is actually
  * allowed to subscribe to. This helper is fully generic — it never inspects the

package/src/schema/schema.ts

@@ -27,6 +27,7 @@ import { AbloValidationError } from '../errors.js';
 import type { IdentityRole } from './roles.js';
 import { fieldRef, type FieldRef } from './fieldRef.js';
 import { scopeSchema, grantsRefSchema } from './roles.js';
+import { subjectRuleSchema } from './subject.js';
 
 // Sync-group roles (identity and entity) are defined in `./roles.js` and
 // re-exported here so they can also be imported from this module. See
@@ -49,6 +50,9 @@ export {
   extractEntityIds,
   composeIdentitySyncGroups,
   composeEntitySyncGroups,
+  syncGroupsForRow,
+  InvalidRecordSubjectError,
+  type RecordSyncGroupSpec,
   intersectRequestedWithAllowed,
   syncGroup,
   identityAnchor,
@@ -150,6 +154,7 @@ export const RESERVED_SESSION_SETTINGS: readonly string[] = [
   'app.current_participant_id',
   'app.current_participant_kind',
   'app.current_user_id',
+  'app.current_subject_groups',
 ];
 
 export interface DefineSchemaOptions {
@@ -523,14 +528,34 @@ export type InsertValue<S extends Schema, ModelName extends keyof S['models']> =
 export type UpsertValue<S extends Schema, ModelName extends keyof S['models']> =
   InsertValue<S, ModelName>;
 
+/**
+ * A patch over a row's fields: send a field to change it, omit it to leave it,
+ * send `null` to CLEAR it.
+ *
+ * The third of those is why this is a mapped type rather than `Partial`.
+ * Omitting a field and clearing a field are different intentions that
+ * `Partial` spells the same way, because `undefined` is what an absent key
+ * already means: it is dropped from the payload, so a caller who wrote
+ * `{ assigneeId: undefined }` to unassign kept the old assignee, and the
+ * unassign, the un-project and the cleared due date all did nothing without
+ * erroring. `null` is the value that clears, so `null` is what the type has to
+ * accept — otherwise the only way to write a working clear is to cast the
+ * payload, and a cast is what people reached for.
+ *
+ * Only a field the schema lets be absent is clearable. A required field cannot
+ * be nulled, which is the same rule the column has.
+ */
+export type Clearable<T> = {
+  [K in keyof T]?: undefined extends T[K] ? T[K] | null : T[K];
+};
+
 /**
  * The value type for updating an existing row. `id` is required (identifies
- * the row to update); all other fields are optional (only provided fields
- * are changed).
+ * the row to update); every other field is a {@link Clearable} patch.
  */
 export type UpdateValue<S extends Schema, ModelName extends keyof S['models']> =
   S['models'][ModelName] extends ModelDef<infer Shape>
-    ? { id: string } & Partial<z.input<z.ZodObject<Shape>>>
+    ? { id: string } & Clearable<z.input<z.ZodObject<Shape>>>
     : never;
 
 /**
@@ -708,6 +733,7 @@ export function defineSchema<const S extends SchemaRecord>(
   }
 
   validateSyncGroupSchema(resolvedModels);
+  validateSubjectSchema(resolvedModels);
   validateSessionSettings(options?.sessionSettings ?? {});
 
   return {
@@ -721,6 +747,45 @@ export function defineSchema<const S extends SchemaRecord>(
   };
 }
 
+function validateSubjectSchema(models: Record<string, ModelDef>): void {
+  for (const [name, def] of Object.entries(models)) {
+    if (!def.subject) continue;
+    const parsed = subjectRuleSchema.safeParse(def.subject);
+    if (!parsed.success) {
+      throw new AbloValidationError(
+        `Model "${name}": subject must be { field, group } with valid identifiers.`,
+        { code: 'schema_definition_invalid', param: `${name}.subject` },
+      );
+    }
+    if (!(def.subject.field in def.fields)) {
+      throw new AbloValidationError(
+        `Model "${name}": subject.field "${def.subject.field}" is not a declared field on this model.`,
+        { code: 'schema_definition_invalid', param: `${name}.subject.field` },
+      );
+    }
+    const field = def.shape[def.subject.field];
+    const meta = def.fields[def.subject.field];
+    if (!field || !meta) {
+      throw new AbloValidationError(
+        `Model "${name}": subject.field "${def.subject.field}" is not a declared field on this model.`,
+        { code: 'schema_definition_invalid', param: `${name}.subject.field` },
+      );
+    }
+    const subjectField = field as z.ZodType;
+    const acceptsInvalidValue =
+      subjectField.safeParse('').success ||
+      subjectField.safeParse(null).success ||
+      subjectField.safeParse(undefined).success ||
+      subjectField.safeParse(1).success;
+    if (!['string', 'enum'].includes(meta.type) || meta.isOptional || acceptsInvalidValue) {
+      throw new AbloValidationError(
+        `Model "${name}": subject.field "${def.subject.field}" must be a required, non-empty string field.`,
+        { code: 'schema_definition_invalid', param: `${name}.subject.field` },
+      );
+    }
+  }
+}
+
 /**
  * Reject session-setting mappings that couldn't do what the author intends —
  * caught here at definition time rather than silently dropped on the write path.

package/src/schema/serialize.ts

@@ -13,7 +13,7 @@
  * What round-trips:
  *   - all model routing and scoping metadata: typename, tableName, load,
  *     mutable, the `tenancy` descriptor, bootstrap hints, scope, grants,
- *     entityRoles, the `conflict` disposition map, persist, autoFill,
+ *     entityRoles, the routing-only acknowledgement, the `conflict` disposition map, persist, autoFill,
  *     requiredFields, and lazyObservable. The authoring shorthands (`policy`
  *     and `groups`) are normalized into these canonical fields when the model
  *     is built, so only the canonical fields cross here.
@@ -33,6 +33,7 @@ import type { FieldMeta } from './field.js';
 import { buildFieldRefs } from './schema.js';
 import type { Tenancy } from './tenancy.js';
 import type { ModelResidency } from './residency.js';
+import type { SubjectRule } from './subject.js';
 import type {
   ModelDef,
   RelationRecord,
@@ -80,6 +81,7 @@ export interface ModelJSON {
   readonly typename: string;
   readonly tableName?: string;
   readonly tenancy: Tenancy;
+  readonly subject?: SubjectRule;
   /** The database plane the model's rows live in. Optional for backward
    *  compatibility: when absent (an artifact written before this field existed)
    *  it reads as `tenant`, the default. See {@link ModelResidency}. */
@@ -87,6 +89,7 @@ export interface ModelJSON {
   readonly scope?: boolean | string;
   readonly grants?: GrantsRef;
   readonly entityRoles?: readonly EntityRole[];
+  readonly routingOnly?: true;
   /** The declared write-conflict disposition per committer kind. When absent,
    *  the engine falls back to its default. */
   readonly conflict?: ConflictAxis;
@@ -136,10 +139,12 @@ function modelToJSON(def: ModelDef): ModelJSON {
     typename: def.typename ?? '',
     tableName: def.tableName,
     tenancy: def.tenancy,
+    subject: def.subject,
     plane: def.plane,
     scope: def.scope,
     grants: def.grants,
     entityRoles: def.entityRoles,
+    routingOnly: def.routingOnly,
     conflict: def.conflict,
     bootstrapLimit: def.bootstrapLimit,
     bootstrapOrderBy: def.bootstrapOrderBy,
@@ -272,12 +277,14 @@ function modelFromJSON(json: ModelJSON): ModelDef {
     persist: json.persist,
     tableName: json.tableName,
     tenancy: json.tenancy,
+    subject: json.subject,
     // Absent in older artifacts → default `tenant`, matching the model builder
     // and provisioning defaults so the round-trip stays stable.
     plane: json.plane ?? 'tenant',
     scope: json.scope,
     grants: json.grants,
     entityRoles: json.entityRoles,
+    routingOnly: json.routingOnly,
     // Absent in older artifacts → undefined, so the commit path falls through to
     // the function registry or the engine default.
     conflict: json.conflict,

package/src/schema/subject.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+
+/**
+ * Row/subject authorization for one model.
+ *
+ * A row is authorized exactly when the authenticated request carries the sync
+ * group `${group}:${row[field]}`. Both values are plain schema data so the rule
+ * survives serialization and can be compiled by every storage plane.
+ */
+export const subjectRuleSchema = z.strictObject({
+  field: z.string().regex(
+    /^[a-zA-Z_][a-zA-Z0-9_]*$/,
+    'subject.field must name a model field',
+  ),
+  group: z.string().regex(
+    /^[a-z][a-z0-9_]*$/,
+    'subject.group must be a lowercase identifier, e.g. "workspace"',
+  ),
+});
+
+export type SubjectRule = z.infer<typeof subjectRuleSchema>;
+
+/** The exact trusted group a row must match, or null for a malformed row. */
+export function subjectGroupForRow(
+  rule: SubjectRule,
+  row: Readonly<Record<string, unknown>>,
+): string | null {
+  const value = row[rule.field];
+  return typeof value === 'string' && value.length > 0
+    ? `${rule.group}:${value}`
+    : null;
+}
+
+/** Fail-closed row check shared by endpoint adapters and in-memory log folds. */
+export function subjectAuthorized(
+  rule: SubjectRule | undefined,
+  row: Readonly<Record<string, unknown>>,
+  groups: readonly string[] | null | undefined,
+): boolean {
+  if (!rule) return true;
+  const required = subjectGroupForRow(rule, row);
+  return required !== null && (groups ?? []).includes(required);
+}

package/src/server/adapter.ts

@@ -25,6 +25,7 @@ import type { ServerSyncDelta } from '../wire/delta.js';
 import type { BootstrapModel } from './readConfig.js';
 import type { CommitContext, CommitExecutionResult } from './commit.js';
 import type { StorageMode } from './storageMode.js';
+import type { SubjectRule } from '../schema/subject.js';
 
 /**
  * A canonical database row: one record, keyed by column name. The value type is
@@ -141,6 +142,7 @@ export type ReadRequest =
       readonly sourceModel?: string;
       /** `__typename` stamped on each returned row. */
       readonly typename: string;
+      readonly subject?: SubjectRule;
       readonly query: SourceListQuery;
       readonly scope?: SourceRequestContext;
       /** Runs the query against a hosted database: compile, take the tenant pool, apply row-level security, unpack the rows. */

package/src/server/readConfig.ts

@@ -19,6 +19,8 @@
  * Plain data, no database driver — it feeds the read side of the data adapter
  * contract, and your query builder reads it to load a model's initial rows.
  */
+import type { SubjectRule } from '../schema/subject.js';
+
 
 /** A mapping from a declared field to a physical column, with the alias to apply after a `SELECT *`. */
 export interface ColumnOverride {
@@ -88,6 +90,8 @@ export interface ReadModelShape {
   readonly orgColumn?: string;
   /** Parent-table scoping for rows with no tenancy column of their own. */
   readonly scopedVia?: ParentScope;
+  /** Credential-bound row authorization compiled by every read plane. */
+  readonly subject?: SubjectRule;
   /** Client-facing field name → physical DB column for declared fields. */
   readonly fieldColumns?: Readonly<Record<string, string>>;
   /** Physical-column aliases needed after SELECT * for `.from(...)` fields. */

package/src/source/adapters/drizzle.ts

@@ -58,6 +58,15 @@ import { toSchemaJSON } from '../../schema/serialize.js';
 import { camelToSnake, snakeToCamel } from '../../schema/ddl.js';
 import { tenancyColumn } from '../../schema/tenancy.js';
 import { ABLO_POSTGRES_COMMIT_ECHO_PREFIX } from '../types.js';
+import {
+  authorizeSourceChange,
+  authorizeSourceRead,
+  lockSourceSubjectCreates,
+  rethrowStrictCreateConflict,
+  sourceSyncGroups,
+  sourceSubjectRule,
+  sourceSubjectValues,
+} from '../subjectAuthorization.js';
 
 /** The subset of a Drizzle database/transaction handle the adapter calls. */
 export interface DrizzleLike {
@@ -214,11 +223,18 @@ export function drizzleDataSource<S extends SchemaRecord>(
       const table = sql.identifier(mc.table);
       if (req.kind === 'load') {
         const rows = rowsOf(await db.execute(sql`SELECT * FROM ${table} WHERE id = ${req.id} LIMIT 1`));
-        return rows.map((r) => toFields(mc, r));
+        return authorizeSourceRead(schema, req, rows.map((r) => toFields(mc, r)));
       }
       const limit = req.query?.limit ?? 1000;
-      const rows = rowsOf(await db.execute(sql`SELECT * FROM ${table} LIMIT ${limit}`));
-      return rows.map((r) => toFields(mc, r));
+      const rule = sourceSubjectRule(schema, req.model);
+      const subjects = sourceSubjectValues(rule, req.scope?.syncGroups);
+      if (subjects?.length === 0) return [];
+      const rows = rowsOf(await db.execute(subjects
+        ? sql`SELECT * FROM ${table}
+              WHERE ${sql.identifier(columnFor(mc, rule!.field))} = ANY(${subjects})
+              LIMIT ${limit}`
+        : sql`SELECT * FROM ${table} LIMIT ${limit}`));
+      return authorizeSourceRead(schema, req, rows.map((r) => toFields(mc, r)));
     },
 
     async commit(change: ChangeSet): Promise<AdapterCommitResult> {
@@ -238,19 +254,46 @@ export function drizzleDataSource<S extends SchemaRecord>(
           return { rows: cachedRow.response as Row[] };
         }
 
+        await lockSourceSubjectCreates(schema, change, async (_operation, key) => {
+          await tx.execute(sql`SELECT pg_advisory_xact_lock(hashtextextended(${key}, 0))`);
+        });
+
+        await authorizeSourceChange(schema, change, async (operation) => {
+          if (!operation.id) return null;
+          const mc = modelColumns(operation.model);
+          const found = rowsOf(
+            await tx.execute(
+              sql`SELECT * FROM ${sql.identifier(mc.table)} WHERE id = ${operation.id} LIMIT 1 FOR UPDATE`,
+            ),
+          )[0];
+          return found ? toFields(mc, found) : null;
+        });
+
         const rows: Row[] = [];
         for (const [index, op] of change.operations.entries()) {
-          const row = await applyOperation(tx, op);
+          let row: Row;
+          try {
+            row = await applyOperation(tx, op);
+          } catch (error) {
+            if (op.type === 'CREATE') rethrowStrictCreateConflict(error, op);
+            throw error;
+          }
           rows.push(row);
           const entityId = String(row.id ?? rowId(op));
+          const syncGroups = sourceSyncGroups(schema, op.model, row);
+          const syncGroupsSql = sql`ARRAY[${sql.join(
+            syncGroups.map((group) => sql`${group}`),
+            sql`, `,
+          )}]::text[]`;
           await tx.execute(sql`
             INSERT INTO ablo_outbox (
-              id, model, entity_id, type, data,
+              id, model, entity_id, type, data, sync_groups,
               correlation_id, transaction_id, occurred_at
             )
             VALUES (
               ${`${change.correlationId}:${index}`}, ${op.model}, ${entityId}, ${op.type},
               ${op.type === 'DELETE' ? null : JSON.stringify(row)}::jsonb,
+              ${syncGroupsSql},
               ${change.correlationId}, ${op.transactionId ?? null}, ${Date.now()}
             )`);
         }
@@ -274,7 +317,7 @@ export function drizzleDataSource<S extends SchemaRecord>(
       const after = cursor ?? '0';
       const rows = rowsOf(
         await db.execute(sql`
-          SELECT cursor, id, model, entity_id, type, data, organization_id,
+          SELECT cursor, id, model, entity_id, type, data, sync_groups, organization_id,
                  client_tx_id, correlation_id, transaction_id, occurred_at
           FROM ablo_outbox WHERE cursor > ${after} ORDER BY cursor ASC LIMIT ${limit}`),
       );
@@ -285,6 +328,7 @@ export function drizzleDataSource<S extends SchemaRecord>(
           entityId: r.entity_id,
           type: r.type,
           data: r.data ?? null,
+          syncGroups: r.sync_groups ?? [],
           organizationId: r.organization_id ?? null,
           clientTxId: r.client_tx_id ?? null,
           correlationId: r.correlation_id ?? null,

package/src/source/adapters/kysely.ts

@@ -46,6 +46,13 @@ import {
   idempotencyLedgerMigrations,
 } from '../migrations.js';
 import { ABLO_POSTGRES_COMMIT_ECHO_PREFIX } from '../types.js';
+import {
+  authorizeSourceChange,
+  authorizeSourceRead,
+  lockSourceSubjectCreates,
+  rethrowStrictCreateConflict,
+  sourceSyncGroups,
+} from '../subjectAuthorization.js';
 import {
   createKyselyMutationCore,
   kyselyOperationRowId,
@@ -259,6 +266,8 @@ export interface KyselyMutationAdapterOptions {
    * typenames equal its keys.
    */
   readonly markerModelFor?: (operationModel: string) => string;
+  /** Schema required to enforce row/subject authorization in this adapter. */
+  readonly schema?: Schema;
 }
 
 export function createKyselyMutationAdapter(
@@ -287,8 +296,9 @@ export function createKyselyMutationAdapter(
         : idempotencyLedgerMigrations();
     },
 
-    read(request) {
-      return core.read(request);
+    async read(request) {
+      const rows = await core.read(request);
+      return options.schema ? authorizeSourceRead(options.schema, request, rows) : rows;
     },
 
     async commit(change: ChangeSet): Promise<AdapterCommitResult> {
@@ -326,6 +336,25 @@ export function createKyselyMutationAdapter(
           return { rows: parseCachedRows(cachedRow.response) };
         }
 
+        if (options.schema) {
+          await lockSourceSubjectCreates(options.schema, request, async (_operation, key) => {
+            await transaction.executeQuery(rawQuery(
+              'subject-create-lock',
+              'SELECT pg_advisory_xact_lock(hashtextextended($1, 0))',
+              [key],
+            ));
+          });
+          await authorizeSourceChange(options.schema, request, async (operation) => {
+            if (!operation.id) return null;
+            const rows = await core.read(
+              { kind: 'load', model: operation.model, id: operation.id },
+              transaction,
+              { forUpdate: true },
+            );
+            return rows[0] ?? null;
+          });
+        }
+
         // Direct mode dispatches every operation before awaiting any of them, so
         // the driver pipelines them into one trip instead of paying a full
         // round trip per row. Postgres still executes them IN ORDER on the
@@ -339,9 +368,17 @@ export function createKyselyMutationAdapter(
         // returned row, so operation i+1's write cannot be dispatched before
         // operation i has answered.
         const rows: Row[] = [];
+        const applyStrict = async (operation: ChangeSet['operations'][number]): Promise<Row> => {
+          try {
+            return await core.applyOperation(transaction, operation);
+          } catch (error) {
+            if (operation.type === 'CREATE') rethrowStrictCreateConflict(error, operation);
+            throw error;
+          }
+        };
         if (mode === 'direct') {
           const dispatched = request.operations.map((operation) =>
-            core.applyOperation(transaction, operation),
+            applyStrict(operation),
           );
           // Settle every dispatch before inspecting, so a later rejection is
           // never an unhandled rejection, then surface the FIRST failure in
@@ -354,7 +391,7 @@ export function createKyselyMutationAdapter(
           }
         } else {
           for (const [index, operation] of request.operations.entries()) {
-            const row = await core.applyOperation(transaction, operation);
+            const row = await applyStrict(operation);
             rows.push(row);
 
             const entityId = String(row.id ?? kyselyOperationRowId(operation));
@@ -366,6 +403,9 @@ export function createKyselyMutationAdapter(
                 entity_id: entityId,
                 type: operation.type,
                 data: operation.type === 'DELETE' ? null : JSON.stringify(row),
+                sync_groups: options.schema
+                  ? sourceSyncGroups(options.schema, operation.model, row)
+                  : [],
                 correlation_id: request.correlationId,
                 transaction_id: operation.transactionId ?? null,
                 occurred_at: Date.now(),
@@ -402,6 +442,7 @@ export function kyselyDataSource<S extends SchemaRecord>(
     db,
     createKyselyMutationCore(db, schema),
     'endpoint',
+    { schema },
   );
 
   return defineDatabaseAdapter({
@@ -423,6 +464,7 @@ export function kyselyDataSource<S extends SchemaRecord>(
           entityId: row.entity_id,
           type: row.type,
           data: typeof row.data === 'string' ? JSON.parse(row.data) : row.data ?? null,
+          syncGroups: row.sync_groups ?? [],
           organizationId: row.organization_id ?? null,
           clientTxId: row.client_tx_id ?? null,
           correlationId: row.correlation_id ?? null,
@@ -458,6 +500,7 @@ export function kyselyDirectMutation<S extends SchemaRecord>(
         markerModels.get(operationModel) ??
         markerModels.get(operationModel.toLowerCase()) ??
         operationModel,
+      schema,
     },
   );
 }

package/src/source/adapters/kyselyMutationCore.ts

@@ -15,6 +15,7 @@ import { camelToSnake, snakeToCamel } from '../../schema/ddl.js';
 import { tenancyColumn } from '../../schema/tenancy.js';
 import type { AdapterReadRequest, Row } from '../adapter.js';
 import type { Operation } from '../contract.js';
+import { sourceSubjectRule, sourceSubjectValues } from '../subjectAuthorization.js';
 
 /** The subset of a Kysely instance, or transaction handle, used by the core. */
 export interface KyselyLike {
@@ -48,6 +49,7 @@ export interface KyselySelectBuilder {
   where(column: string, operator: string, value: unknown): KyselySelectBuilder;
   orderBy(column: string, direction: 'asc' | 'desc'): KyselySelectBuilder;
   limit(limit: number): KyselySelectBuilder;
+  forUpdate(): KyselySelectBuilder;
   execute(): Promise<readonly Row[]>;
 }
 
@@ -140,7 +142,11 @@ function suppliedOperationRowId(operation: Operation): string | undefined {
 
 /** The transport-independent Kysely field/column mutation boundary. */
 export interface KyselyMutationCore {
-  read(request: AdapterReadRequest): Promise<readonly Row[]>;
+  read(
+    request: AdapterReadRequest,
+    database?: KyselyLike,
+    options?: { readonly forUpdate?: boolean },
+  ): Promise<readonly Row[]>;
   applyOperation(transaction: KyselyLike, operation: Operation): Promise<Row>;
 }
 
@@ -185,22 +191,28 @@ export function createKyselyMutationCore<S extends SchemaRecord>(
   };
 
   return {
-    async read(request): Promise<readonly Row[]> {
+    async read(request, database = db, options): Promise<readonly Row[]> {
       const columns = modelColumns(request.model);
       if (request.kind === 'load') {
-        const rows = await db
+        let query = database
           .selectFrom(columns.table)
           .selectAll()
           .where(columnFor(columns, 'id'), '=', request.id)
-          .limit(1)
-          .execute();
+          .limit(1);
+        if (options?.forUpdate) query = query.forUpdate();
+        const rows = await query.execute();
         return rows.map((row) => toFields(columns, row));
       }
-      const rows = await db
+      let query = database
         .selectFrom(columns.table)
-        .selectAll()
-        .limit(request.query?.limit ?? 1000)
-        .execute();
+        .selectAll();
+      const rule = sourceSubjectRule(schema, request.model);
+      const subjects = sourceSubjectValues(rule, request.scope?.syncGroups);
+      if (subjects) {
+        if (subjects.length === 0) return [];
+        query = query.where(columnFor(columns, rule!.field), 'in', subjects);
+      }
+      const rows = await query.limit(request.query?.limit ?? 1000).execute();
       return rows.map((row) => toFields(columns, row));
     },
 

package/src/source/adapters/memory.ts

@@ -141,6 +141,7 @@ export function memoryDataSource(): DataSourceAdapter {
           entityId: String(row.id ?? rowId(op)),
           type: op.type,
           data: op.type === 'DELETE' ? null : row,
+          syncGroups: [],
           correlationId: change.correlationId,
           ...(op.transactionId ? { transactionId: op.transactionId } : {}),
           cursor: String(outbox.length + 1),