@graffiti-garden/api 0.3.0 → 0.4.0

package/src/index.ts

@@ -1,4 +1,4 @@
 export * from "./1-api";
 export * from "./2-types";
 export * from "./3-errors";
-export type { JSONSchema4 } from "json-schema";
+export type { JSONSchema } from "json-schema-to-ts";

package/tests/channel-stats.ts

@@ -38,7 +38,7 @@ export const graffitiChannelStatsTests = (
       // one value to channels[2]
       for (let i = 0; i < 3; i++) {
         for (let j = 0; j < i + 1; j++) {
-          await graffiti.put(
+          await graffiti.put<{}>(
             {
               value: {
                 index: j,
@@ -49,7 +49,7 @@ export const graffitiChannelStatsTests = (
           );
         }
       }
-      await graffiti.put(
+      await graffiti.put<{}>(
         { value: { index: 3 }, channels: [channels[2]] },
         session,
       );
@@ -76,7 +76,7 @@ export const graffitiChannelStatsTests = (
       const channels = [randomString(), randomString(), randomString()];
 
       // Add an item with two channels
-      const before = await graffiti.put(
+      const before = await graffiti.put<{}>(
         {
           value: { index: 2 },
           channels: channels.slice(1),
@@ -85,7 +85,7 @@ export const graffitiChannelStatsTests = (
       );
 
       // Add an item with all channels
-      const first = await graffiti.put(
+      const first = await graffiti.put<{}>(
         { value: { index: 0 }, channels },
         session,
       );
@@ -93,7 +93,7 @@ export const graffitiChannelStatsTests = (
       await graffiti.delete(first, session);
 
       // Create a new object with only one channel
-      const second = await graffiti.put(
+      const second = await graffiti.put<{}>(
         {
           value: { index: 1 },
           channels: channels.slice(2),

package/tests/crud.ts

@@ -3,7 +3,9 @@ import type {
   Graffiti,
   GraffitiSession,
   GraffitiPatch,
+  JSONSchema,
 } from "@graffiti-garden/api";
+import type { FromSchema } from "json-schema-to-ts";
 import {
   GraffitiErrorNotFound,
   GraffitiErrorSchemaMismatch,
@@ -43,7 +45,7 @@ export const graffitiCRUDTests = (
         const channels = [randomString(), randomString()];
 
         // Put the object
-        const previous = await graffiti.put({ value, channels }, session);
+        const previous = await graffiti.put<{}>({ value, channels }, session);
         expect(previous.value).toEqual({});
         expect(previous.channels).toEqual([]);
         expect(previous.allowed).toBeUndefined();
@@ -63,7 +65,7 @@ export const graffitiCRUDTests = (
         const newValue = {
           something: "goodbye, world~ :c",
         };
-        const beforeReplaced = await graffiti.put(
+        const beforeReplaced = await graffiti.put<{}>(
           { ...previous, value: newValue, channels: [] },
           session,
         );
@@ -96,7 +98,7 @@ export const graffitiCRUDTests = (
       });
 
       it("get non-existant", async () => {
-        const putted = await graffiti.put(randomPutObject(), session);
+        const putted = await graffiti.put<{}>(randomPutObject(), session);
         await expect(
           graffiti.get(
             {
@@ -110,13 +112,13 @@ export const graffitiCRUDTests = (
 
       it("put, get, delete with wrong actor", async () => {
         await expect(
-          graffiti.put(
+          graffiti.put<{}>(
             { value: {}, channels: [], actor: session2.actor },
             session1,
           ),
         ).rejects.toThrow(GraffitiErrorForbidden);
 
-        const putted = await graffiti.put(
+        const putted = await graffiti.put<{}>(
           { value: {}, channels: [] },
           session2,
         );
@@ -139,17 +141,33 @@ export const graffitiCRUDTests = (
                   type: "string",
                 },
                 another: {
-                  type: "integer",
+                  type: "array",
+                  items: {
+                    type: "number",
+                  },
+                },
+                deeper: {
+                  type: "object",
+                  properties: {
+                    deepProp: {
+                      type: "string",
+                    },
+                  },
+                  required: ["deepProp"],
                 },
               },
+              required: ["another", "deeper"],
             },
           },
-        } as const;
+        } as const satisfies JSONSchema;
 
         const goodValue = {
           something: "hello",
-          another: 42,
-        } as const;
+          another: [1, 2, 3],
+          deeper: {
+            deepProp: "hello",
+          },
+        };
 
         const putted = await graffiti.put<typeof schema>(
           {
@@ -158,14 +176,19 @@ export const graffitiCRUDTests = (
           },
           session,
         );
-
         const gotten = await graffiti.get(putted, schema);
+
         expect(gotten.value.something).toEqual(goodValue.something);
         expect(gotten.value.another).toEqual(goodValue.another);
+        expect(gotten.value.another[0]).toEqual(1);
+        expect(gotten.value.deeper.deepProp).toEqual(goodValue.deeper.deepProp);
       });
 
       it("put and get with invalid schema", async () => {
-        const putted = await graffiti.put({ value: {}, channels: [] }, session);
+        const putted = await graffiti.put<{}>(
+          { value: {}, channels: [] },
+          session,
+        );
         await expect(
           graffiti.get(putted, {
             properties: {
@@ -179,7 +202,7 @@ export const graffitiCRUDTests = (
       });
 
       it("put and get with wrong schema", async () => {
-        const putted = await graffiti.put(
+        const putted = await graffiti.put<{}>(
           {
             value: {
               hello: "world",
@@ -210,7 +233,7 @@ export const graffitiCRUDTests = (
         };
         const allowed = [randomString()];
         const channels = [randomString()];
-        const putted = await graffiti.put(
+        const putted = await graffiti.put<{}>(
           { value, allowed, channels },
           session1,
         );
@@ -238,7 +261,7 @@ export const graffitiCRUDTests = (
         };
         const allowed = [randomString(), session2.actor, randomString()];
         const channels = [randomString()];
-        const putted = await graffiti.put(
+        const putted = await graffiti.put<{}>(
           {
             value,
             allowed,
@@ -270,7 +293,7 @@ export const graffitiCRUDTests = (
         const value = {
           something: "hello, world~ c:",
         };
-        const putted = await graffiti.put({ value, channels: [] }, session);
+        const putted = await graffiti.put<{}>({ value, channels: [] }, session);
 
         // Wait just a bit to make sure the lastModified is different
         await new Promise((resolve) => setTimeout(resolve, 10));
@@ -295,7 +318,7 @@ export const graffitiCRUDTests = (
       });
 
       it("patch deleted object", async () => {
-        const putted = await graffiti.put(randomPutObject(), session);
+        const putted = await graffiti.put<{}>(randomPutObject(), session);
         const deleted = await graffiti.delete(putted, session);
         await expect(
           graffiti.patch({}, putted, session),
@@ -310,7 +333,7 @@ export const graffitiCRUDTests = (
             },
           },
         };
-        const putted = await graffiti.put(
+        const putted = await graffiti.put<{}>(
           { value: value, channels: [] },
           session,
         );
@@ -344,7 +367,7 @@ export const graffitiCRUDTests = (
         const channelsBefore = [randomString()];
         const channelsAfter = [randomString()];
 
-        const putted = await graffiti.put(
+        const putted = await graffiti.put<{}>(
           { value: {}, channels: channelsBefore },
           session,
         );
@@ -360,7 +383,7 @@ export const graffitiCRUDTests = (
       });
 
       it("patch 'increment' with test", async () => {
-        const putted = await graffiti.put(
+        const putted = await graffiti.put<{}>(
           {
             value: {
               counter: 1,
@@ -410,7 +433,7 @@ export const graffitiCRUDTests = (
 
       it("invalid patch", async () => {
         const object = randomPutObject();
-        const putted = await graffiti.put(object, session);
+        const putted = await graffiti.put<{}>(object, session);
 
         await expect(
           graffiti.patch(
@@ -429,7 +452,7 @@ export const graffitiCRUDTests = (
       it("patch channels to be wrong", async () => {
         const object = randomPutObject();
         object.allowed = [randomString()];
-        const putted = await graffiti.put(object, session);
+        const putted = await graffiti.put<{}>(object, session);
 
         const patches: GraffitiPatch[] = [
           {

package/tests/discover.ts

@@ -2,7 +2,7 @@ import { it, expect, describe, assert, beforeAll } from "vitest";
 import type {
   Graffiti,
   GraffitiSession,
-  JSONSchema4,
+  JSONSchema,
 } from "@graffiti-garden/api";
 import { randomString, nextStreamValue, randomPutObject } from "./utils";
 
@@ -31,7 +31,7 @@ export const graffitiDiscoverTests = (
     it("discover single", async () => {
       const object = randomPutObject();
 
-      const putted = await graffiti.put(object, session);
+      const putted = await graffiti.put<{}>(object, session);
 
       const queryChannels = [randomString(), object.channels[0]];
       const iterator = graffiti.discover(queryChannels, {});
@@ -48,7 +48,7 @@ export const graffitiDiscoverTests = (
 
     it("discover wrong channel", async () => {
       const object = randomPutObject();
-      await graffiti.put(object, session);
+      await graffiti.put<{}>(object, session);
       const iterator = graffiti.discover([randomString()], {});
       await expect(iterator.next()).resolves.toHaveProperty("done", true);
     });
@@ -56,7 +56,7 @@ export const graffitiDiscoverTests = (
     it("discover not allowed", async () => {
       const object = randomPutObject();
       object.allowed = [randomString(), randomString()];
-      const putted = await graffiti.put(object, session1);
+      const putted = await graffiti.put<{}>(object, session1);
 
       const iteratorSession1 = graffiti.discover(object.channels, {}, session1);
       const value = await nextStreamValue(iteratorSession1);
@@ -77,7 +77,7 @@ export const graffitiDiscoverTests = (
     it("discover allowed", async () => {
       const object = randomPutObject();
       object.allowed = [randomString(), session2.actor, randomString()];
-      const putted = await graffiti.put(object, session1);
+      const putted = await graffiti.put<{}>(object, session1);
 
       const iteratorSession2 = graffiti.discover(object.channels, {}, session2);
       const value = await nextStreamValue(iteratorSession2);
@@ -92,13 +92,13 @@ export const graffitiDiscoverTests = (
     for (const prop of ["name", "actor", "lastModified"] as const) {
       it(`discover for ${prop}`, async () => {
         const object1 = randomPutObject();
-        const putted1 = await graffiti.put(object1, session1);
+        const putted1 = await graffiti.put<{}>(object1, session1);
 
         const object2 = randomPutObject();
         object2.channels = object1.channels;
         // Make sure the lastModified is different for the query
         await new Promise((r) => setTimeout(r, 20));
-        const putted2 = await graffiti.put(object2, session2);
+        const putted2 = await graffiti.put<{}>(object2, session2);
 
         const iterator = graffiti.discover(object1.channels, {
           properties: {
@@ -118,10 +118,10 @@ export const graffitiDiscoverTests = (
 
     it("discover with lastModified range", async () => {
       const object = randomPutObject();
-      const putted1 = await graffiti.put(object, session);
+      const putted1 = await graffiti.put<{}>(object, session);
       // Make sure the lastModified is different
       await new Promise((r) => setTimeout(r, 20));
-      const putted2 = await graffiti.put(object, session);
+      const putted2 = await graffiti.put<{}>(object, session);
 
       expect(putted1.name).not.toEqual(putted2.name);
       expect(putted1.lastModified).toBeLessThan(putted2.lastModified);
@@ -129,8 +129,7 @@ export const graffitiDiscoverTests = (
       const gtIterator = graffiti.discover([object.channels[0]], {
         properties: {
           lastModified: {
-            minimum: putted2.lastModified,
-            exclusiveMinimum: true,
+            exclusiveMinimum: putted2.lastModified,
           },
         },
       });
@@ -138,8 +137,7 @@ export const graffitiDiscoverTests = (
       const gtIteratorEpsilon = graffiti.discover([object.channels[0]], {
         properties: {
           lastModified: {
-            minimum: putted2.lastModified - 0.1,
-            exclusiveMinimum: true,
+            exclusiveMinimum: putted2.lastModified - 0.1,
           },
         },
       });
@@ -169,8 +167,7 @@ export const graffitiDiscoverTests = (
       const ltIterator = graffiti.discover(object.channels, {
         properties: {
           lastModified: {
-            maximum: putted1.lastModified,
-            exclusiveMaximum: true,
+            exclusiveMaximum: putted1.lastModified,
           },
         },
       });
@@ -179,8 +176,7 @@ export const graffitiDiscoverTests = (
       const ltIteratorEpsilon = graffiti.discover(object.channels, {
         properties: {
           lastModified: {
-            maximum: putted1.lastModified + 0.1,
-            exclusiveMaximum: true,
+            exclusiveMaximum: putted1.lastModified + 0.1,
           },
         },
       });
@@ -212,7 +208,7 @@ export const graffitiDiscoverTests = (
     it("discover schema allowed, as and not as owner", async () => {
       const object = randomPutObject();
       object.allowed = [randomString(), session2.actor, randomString()];
-      await graffiti.put(object, session1);
+      await graffiti.put<{}>(object, session1);
 
       const iteratorSession1 = graffiti.discover(
         object.channels,
@@ -304,7 +300,7 @@ export const graffitiDiscoverTests = (
     it("discover schema channels, as and not as owner", async () => {
       const object = randomPutObject();
       object.channels = [randomString(), randomString(), randomString()];
-      await graffiti.put(object, session1);
+      await graffiti.put<{}>(object, session1);
 
       const iteratorSession1 = graffiti.discover(
         [object.channels[0], object.channels[2]],
@@ -400,9 +396,9 @@ export const graffitiDiscoverTests = (
         not: {
           required: ["allowed"],
         },
-      } satisfies JSONSchema4;
+      } satisfies JSONSchema;
 
-      await graffiti.put(publicO, session1);
+      await graffiti.put<{}>(publicO, session1);
       const iterator = graffiti.discover(
         publicO.channels,
         publicSchema,
@@ -415,7 +411,7 @@ export const graffitiDiscoverTests = (
 
       const restricted = randomPutObject();
       restricted.allowed = [];
-      await graffiti.put(restricted, session1);
+      await graffiti.put<{}>(restricted, session1);
       const iterator2 = graffiti.discover(
         restricted.channels,
         publicSchema,
@@ -427,17 +423,17 @@ export const graffitiDiscoverTests = (
     it("discover query for values", async () => {
       const object1 = randomPutObject();
       object1.value = { test: randomString() };
-      await graffiti.put(object1, session);
+      await graffiti.put<{}>(object1, session);
 
       const object2 = randomPutObject();
       object2.channels = object1.channels;
       object2.value = { test: randomString(), something: randomString() };
-      await graffiti.put(object2, session);
+      await graffiti.put<{}>(object2, session);
 
       const object3 = randomPutObject();
       object3.channels = object1.channels;
       object3.value = { other: randomString(), something: randomString() };
-      await graffiti.put(object3, session);
+      await graffiti.put<{}>(object3, session);
 
       const counts = new Map<string, number>();
       for (const property of ["test", "something", "other"] as const) {
@@ -464,7 +460,7 @@ export const graffitiDiscoverTests = (
 
     it("discover for deleted content", async () => {
       const object = randomPutObject();
-      const putted = await graffiti.put(object, session);
+      const putted = await graffiti.put<{}>(object, session);
       const deleted = await graffiti.delete(putted, session);
 
       const iterator = graffiti.discover(object.channels, {});
@@ -481,9 +477,9 @@ export const graffitiDiscoverTests = (
       // Do this a bunch to check for concurrency issues
       for (let i = 0; i < 10; i++) {
         const object1 = randomPutObject();
-        const putted = await graffiti.put(object1, session);
+        const putted = await graffiti.put<{}>(object1, session);
         const object2 = randomPutObject();
-        const replaced = await graffiti.put(
+        const replaced = await graffiti.put<{}>(
           {
             ...putted,
             ...object2,
@@ -520,7 +516,7 @@ export const graffitiDiscoverTests = (
 
     it("discover for patched allowed", async () => {
       const object = randomPutObject();
-      const putted = await graffiti.put(object, session);
+      const putted = await graffiti.put<{}>(object, session);
       await graffiti.patch(
         {
           allowed: [{ op: "add", path: "", value: [] }],
@@ -543,7 +539,7 @@ export const graffitiDiscoverTests = (
 
       const putPromises = Array(100)
         .fill(0)
-        .map(() => graffiti.put(object, session));
+        .map(() => graffiti.put<{}>(object, session));
       await Promise.all(putPromises);
 
       const iterator = graffiti.discover(object.channels, {});

package/tests/orphans.ts

@@ -32,7 +32,7 @@ export const graffitiOrphanTests = (
 
       const object = randomPutObject();
       object.channels = [];
-      const putted = await graffiti.put(object, session);
+      const putted = await graffiti.put<{}>(object, session);
       const orphanIterator2 = graffiti.recoverOrphans({}, session);
       let numResults = 0;
       for await (const orphan of orphanIterator2) {
@@ -49,12 +49,12 @@ export const graffitiOrphanTests = (
     it("replaced orphan, no longer", async () => {
       const object = randomPutObject();
       object.channels = [];
-      const putOrphan = await graffiti.put(object, session);
+      const putOrphan = await graffiti.put<{}>(object, session);
 
       // Wait for the put to be processed
       await new Promise((resolve) => setTimeout(resolve, 10));
 
-      const putNotOrphan = await graffiti.put(
+      const putNotOrphan = await graffiti.put<{}>(
         {
           ...putOrphan,
           ...object,