jazz-tools 0.10.14 → 0.11.0

package/src/tests/schema.test.ts

@@ -140,6 +140,15 @@ describe("co.json TypeScript validation", () => {
       }>();
   });
 
+  it("should flag types with symbol keys as invalid", async () => {
+    type InvalidType = { [key: symbol]: string };
+
+    class InvalidFunctionMap extends CoMap {
+      // @ts-expect-error Should not be considered valid
+      data = co.json<InvalidType>();
+    }
+  });
+
   it("should apply the same validation to optional json", async () => {
     type ValidType = {
       value: string;
@@ -163,17 +172,48 @@ describe("co.json TypeScript validation", () => {
       }>();
   });
 
+  /* Special case from reported issue:
+   ** See: https://github.com/garden-co/jazz/issues/1496
+   */
+  it("should apply the same validation to optional json [JAZZ-1496]", async () => {
+    interface ValidInterface0 {
+      value: string;
+    }
+    interface ValidInterface1 {
+      value: string | undefined;
+    }
+    interface InterfaceWithOptionalTypes {
+      requiredValue: string;
+      value?: string;
+    }
+
+    class MapWithOptionalJSON extends CoMap {
+      data1 = co.optional.json<ValidInterface0>();
+      data2 = co.optional.json<ValidInterface1>();
+      data3 = co.optional.json<InterfaceWithOptionalTypes>();
+    }
+
+    expectTypeOf(MapWithOptionalJSON.create<MapWithOptionalJSON>)
+      .parameter(0)
+      .toEqualTypeOf<{
+        data1?: valueWithCoMarker<ValidInterface0> | null;
+        data2?: valueWithCoMarker<ValidInterface1> | null;
+        data3?: valueWithCoMarker<InterfaceWithOptionalTypes> | null;
+      }>();
+  });
+
   it("should not accept functions", async () => {
     class InvalidFunctionMap extends CoMap {
       // @ts-expect-error Should not be considered valid
       data = co.json<() => void>();
     }
+  });
 
-    expectTypeOf(InvalidFunctionMap.create<InvalidFunctionMap>)
-      .parameter(0)
-      .toEqualTypeOf<{
-        data: valueWithCoMarker<() => void>;
-      }>();
+  it("should not accept functions in nested properties", async () => {
+    class InvalidFunctionMap extends CoMap {
+      // @ts-expect-error Should not be considered valid
+      data = co.json<{ func: () => void }>();
+    }
   });
 
   it("should not accept RegExp", async () => {

package/src/tests/utils.ts

@@ -44,7 +44,11 @@ export async function setupAccount() {
   return { me, meOnSecondPeer };
 }
 
-export async function setupTwoNodes() {
+export async function setupTwoNodes(options?: {
+  ServerAccountSchema?: typeof Account;
+}) {
+  const ServerAccountSchema = options?.ServerAccountSchema ?? Account;
+
   const [serverAsPeer, clientAsPeer] = cojsonInternals.connectedPeers(
     "clientToServer",
     "serverToClient",
@@ -72,7 +76,7 @@ export async function setupTwoNodes() {
     crypto: Crypto,
     creationProps: { name: "Server" },
     migration: async (rawAccount, _node, creationProps) => {
-      const account = new Account({
+      const account = new ServerAccountSchema({
         fromRaw: rawAccount,
       });
 
@@ -86,7 +90,7 @@ export async function setupTwoNodes() {
     clientAccount: Account.fromRaw(
       await loadCoValueOrFail(client.node, client.accountID),
     ),
-    serverAccount: Account.fromRaw(
+    serverAccount: ServerAccountSchema.fromRaw(
       await loadCoValueOrFail(server.node, server.accountID),
     ),
   };

package/src/types.ts

@@ -57,3 +57,9 @@ export type SyncConfig =
       peer?: `wss://${string}` | `ws://${string}`;
       when: "never";
     };
+
+export interface Register {}
+
+export type RegisteredAccount = Register extends { Account: infer Acc }
+  ? Acc
+  : Account;

package/tsconfig.json

@@ -9,7 +9,10 @@
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
     "noUncheckedIndexedAccess": true,
-    "esModuleInterop": true
+    "esModuleInterop": true,
+    "declaration": true,
+    "emitDeclarationOnly": true,
+    "declarationMap": true
   },
   "include": ["./src/**/*.ts"],
   "exclude": ["./node_modules"]