@pylonsync/sdk 0.3.350 → 0.3.351

package/dist/index.d.ts

@@ -325,7 +325,10 @@ export declare function entity(name: string, fields: Record<string, FieldBuilder
     indexes?: IndexDefinition[];
     relations?: RelationDefinition[];
     search?: SearchConfig;
-    sync?: boolean;
+    /** `false` to keep out of the replica, or a {@link SyncScope} to bound
+     *  which rows reach it. Mirrors {@link EntityDefinition.sync} — this is
+     *  the type callers actually hit, so the two must not drift. */
+    sync?: boolean | SyncScope;
 }): EntityDefinition;
 export declare function relation(def: RelationDefinition): RelationDefinition;
 export type AuthMode = "public" | "user";

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.3.350",
+  "version": "0.3.351",
   "type": "module",
   "main": "./src/index.ts",
   "types": "./dist/index.d.ts",

package/src/index.ts

@@ -415,7 +415,10 @@ export function entity(
     indexes?: IndexDefinition[];
     relations?: RelationDefinition[];
     search?: SearchConfig;
-    sync?: boolean;
+    /** `false` to keep out of the replica, or a {@link SyncScope} to bound
+     *  which rows reach it. Mirrors {@link EntityDefinition.sync} — this is
+     *  the type callers actually hit, so the two must not drift. */
+    sync?: boolean | SyncScope;
   },
 ): EntityDefinition {
   return {

package/src/sdk.types.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, test } from "bun:test";
+import { buildManifest, entity, field } from "./index";
+
+/**
+ * The shape callers actually hit.
+ *
+ * `EntityDefinition.sync` and the `entity(name, fields, options)` options
+ * parameter declare the same field twice, and they drifted the moment
+ * `SyncScope` was added: the interface accepted a scope, the function did not,
+ * so `sync: { limit: 2000 }` was a type error in every real app while the
+ * feature looked shipped. These assert through `entity()` — the public door —
+ * so the two can't diverge again unnoticed.
+ */
+describe("entity() sync option", () => {
+  const fields = { orgId: field.string(), views: field.int() };
+
+  const manifestFor = (e: ReturnType<typeof entity>) =>
+    buildManifest({
+      name: "t",
+      version: "1",
+      entities: [e],
+      policies: [],
+      queries: [],
+      actions: [],
+      routes: [],
+    }) as unknown as {
+      entities: Array<{
+        name: string;
+        sync?: boolean;
+        sync_scope?: string;
+        sync_limit?: number;
+      }>;
+    };
+
+  test("accepts a scope object, not just a boolean", () => {
+    const e = entity("Snap", fields, {
+      sync: { where: "data.orgId == auth.tenantId", limit: 2000 },
+    });
+    expect(e.sync).toEqual({
+      where: "data.orgId == auth.tenantId",
+      limit: 2000,
+    });
+  });
+
+  test("a scope reaches the manifest as flat sibling keys", () => {
+    // Flattened so `sync` stays a bool on the wire — an older binary reading a
+    // newer manifest replicates everything instead of failing to parse.
+    const snap = manifestFor(
+      entity("Snap", fields, {
+        sync: { where: "data.orgId == auth.tenantId", limit: 2000 },
+      }),
+    ).entities[0];
+    expect(snap.sync).toBeUndefined(); // still the default: true
+    expect(snap.sync_scope).toBe("data.orgId == auth.tenantId");
+    expect(snap.sync_limit).toBe(2000);
+  });
+
+  test("a limit with no predicate emits no scope expression", () => {
+    const snap = manifestFor(entity("Snap", fields, { sync: { limit: 500 } }))
+      .entities[0];
+    expect(snap.sync_scope).toBeUndefined();
+    expect(snap.sync_limit).toBe(500);
+  });
+
+  test("sync: false still opts out entirely", () => {
+    expect(manifestFor(entity("Snap", fields, { sync: false })).entities[0].sync)
+      .toBe(false);
+  });
+});