@graffiti-garden/wrapper-synchronize 0.0.1 → 0.0.3

package/dist/index.d.ts

@@ -1,9 +1,23 @@
-import Ajv from "ajv-draft-04";
+import type Ajv from "ajv";
 import { Graffiti } from "@graffiti-garden/api";
-import type { GraffitiSession, GraffitiObject, JSONSchema4, GraffitiStream } from "@graffiti-garden/api";
+import type { GraffitiSession, GraffitiObject, JSONSchema, GraffitiStream } from "@graffiti-garden/api";
 import type { GraffitiObjectBase } from "@graffiti-garden/api";
+import type { applyPatch } from "fast-json-patch";
 export type * from "@graffiti-garden/api";
 export type GraffitiSynchronizeCallback = (oldObject: GraffitiObjectBase, newObject?: GraffitiObjectBase) => void;
+export interface GraffitiSynchronizeOptions {
+    /**
+     * Allows synchronize to listen to all objects, not just those
+     * that the session is allowed to see. This is useful to get a
+     * global view of all Graffiti objects passsing through the system,
+     * for example to build a client-side cache. Additional mechanisms
+     * should be in place to ensure that users do not see objects or
+     * properties they are not allowed to see.
+     *
+     * Default: `false`
+     */
+    omniscient?: boolean;
+}
 /**
  * Wraps the [Graffiti API](https://api.graffiti.garden/classes/Graffiti.html)
  * so that changes made or received in one part of an application
@@ -47,15 +61,19 @@ export type GraffitiSynchronizeCallback = (oldObject: GraffitiObjectBase, newObj
  * streams appropriate changes to provide a responsive and consistent user experience.
  */
 export declare class GraffitiSynchronize extends Graffiti {
-    protected readonly ajv: Ajv;
+    protected ajv_: Promise<Ajv> | undefined;
+    protected applyPatch_: Promise<typeof applyPatch> | undefined;
     protected readonly graffiti: Graffiti;
     protected readonly callbacks: Set<GraffitiSynchronizeCallback>;
+    protected readonly options: GraffitiSynchronizeOptions;
     channelStats: Graffiti["channelStats"];
     locationToUri: Graffiti["locationToUri"];
     uriToLocation: Graffiti["uriToLocation"];
     login: Graffiti["login"];
     logout: Graffiti["logout"];
     sessionEvents: Graffiti["sessionEvents"];
+    get ajv(): Promise<Ajv>;
+    get applyPatch(): Promise<typeof applyPatch>;
     /**
      * Wraps a Graffiti API instance to provide the synchronize methods.
      * The GraffitiSyncrhonize class rather than the Graffiti class
@@ -66,14 +84,8 @@ export declare class GraffitiSynchronize extends Graffiti {
      * The [Graffiti API](https://api.graffiti.garden/classes/Graffiti.html)
      * instance to wrap.
      */
-    graffiti: Graffiti, 
-    /**
-     * An optional instance of Ajv to use for validating
-     * objects before dispatching them to listeners.
-     * If not provided, a new instance of Ajv will be created.
-     */
-    ajv?: Ajv);
-    protected synchronize<Schema extends JSONSchema4>(matchObject: (object: GraffitiObjectBase) => boolean, channels: string[], schema: Schema, session?: GraffitiSession | null): GraffitiStream<GraffitiObject<Schema>>;
+    graffiti: Graffiti, options?: GraffitiSynchronizeOptions);
+    protected synchronize<Schema extends JSONSchema>(matchObject: (object: GraffitiObjectBase) => boolean, channels: string[], schema: Schema, session?: GraffitiSession | null): GraffitiStream<GraffitiObject<Schema>>;
     /**
      * This method has the same signature as {@link discover} but listens for
      * changes made via {@link put}, {@link patch}, and {@link delete} or
@@ -87,7 +99,7 @@ export declare class GraffitiSynchronize extends Graffiti {
      *
      * @group Synchronize Methods
      */
-    synchronizeDiscover<Schema extends JSONSchema4>(...args: Parameters<typeof Graffiti.prototype.discover<Schema>>): GraffitiStream<GraffitiObject<Schema>>;
+    synchronizeDiscover<Schema extends JSONSchema>(...args: Parameters<typeof Graffiti.prototype.discover<Schema>>): GraffitiStream<GraffitiObject<Schema>>;
     /**
      * This method has the same signature as {@link get} but
      * listens for changes made via {@link put}, {@link patch}, and {@link delete} or
@@ -99,7 +111,7 @@ export declare class GraffitiSynchronize extends Graffiti {
      *
      * @group Synchronize Methods
      */
-    synchronizeGet<Schema extends JSONSchema4>(...args: Parameters<typeof Graffiti.prototype.get<Schema>>): GraffitiStream<GraffitiObject<Schema>>;
+    synchronizeGet<Schema extends JSONSchema>(...args: Parameters<typeof Graffiti.prototype.get<Schema>>): GraffitiStream<GraffitiObject<Schema>>;
     /**
      * This method has the same signature as {@link recoverOrphans} but
      * listens for changes made via
@@ -113,13 +125,24 @@ export declare class GraffitiSynchronize extends Graffiti {
      *
      * @group Synchronize Methods
      */
-    synchronizeRecoverOrphans<Schema extends JSONSchema4>(...args: Parameters<typeof Graffiti.prototype.recoverOrphans<Schema>>): GraffitiStream<GraffitiObject<Schema>>;
+    synchronizeRecoverOrphans<Schema extends JSONSchema>(...args: Parameters<typeof Graffiti.prototype.recoverOrphans<Schema>>): GraffitiStream<GraffitiObject<Schema>>;
+    /**
+     * Streams changes made to *any* object in *any* channel
+     * and made by *any* user. You may want to use it in conjuction with
+     * {@link GraffitiSyncrhonizeOptions.omniscient} to get a global view
+     * of all Graffiti objects passing through the system. This is useful
+     * for building a client-side cache, for example.
+     *
+     * Be careful using this method. Without additional filters it can
+     * expose the user to content out of context.
+     */
+    synchronizeAll(schema?: JSONSchema, session?: GraffitiSession | null): GraffitiStream<GraffitiObjectBase>;
     protected synchronizeDispatch(oldObject: GraffitiObjectBase, newObject?: GraffitiObjectBase, waitForListeners?: boolean): Promise<void>;
     get: Graffiti["get"];
     put: Graffiti["put"];
     patch: Graffiti["patch"];
     delete: Graffiti["delete"];
-    protected objectStream<Schema extends JSONSchema4>(iterator: ReturnType<typeof Graffiti.prototype.discover<Schema>>): AsyncGenerator<{
+    protected objectStream<Schema extends JSONSchema>(iterator: ReturnType<typeof Graffiti.prototype.discover<Schema>>): AsyncGenerator<{
         error: Error;
         source: string;
     } | {

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@graffiti-garden/wrapper-synchronize",
-  "version": "0.0.1",
-  "description": "TBD",
+  "version": "0.0.3",
+  "description": "Internal synchronization for the Graffiti API",
   "types": "./dist/index.d.ts",
   "module": "./dist/esm/index.js",
   "main": "./dist/cjs/index.js",
@@ -50,14 +50,13 @@
     "tsx": "^4.19.2",
     "typedoc": "^0.27.6",
     "typescript": "^5.7.3",
-    "vitest": "^2.1.9"
+    "vitest": "^3.0.5"
   },
   "dependencies": {
-    "@graffiti-garden/api": "^0.3.0",
-    "@graffiti-garden/implementation-local": "^0.2.12",
+    "@graffiti-garden/api": "^0.4.1",
+    "@graffiti-garden/implementation-local": "^0.4.0",
     "@repeaterjs/repeater": "^3.0.6",
     "ajv": "^8.17.1",
-    "ajv-draft-04": "^1.0.0",
     "fast-json-patch": "^3.1.1"
   }
 }

package/src/index.spec.ts

@@ -2,8 +2,9 @@ import { it, expect, describe, assert, beforeAll } from "vitest";
 import type { GraffitiSession } from "@graffiti-garden/api";
 import { GraffitiLocal } from "@graffiti-garden/implementation-local";
 import { randomPutObject, randomString } from "@graffiti-garden/api/tests";
+import { GraffitiSynchronize } from "./index";
 
-const useGraffiti = () => new GraffitiLocal();
+const useGraffiti = () => new GraffitiSynchronize(new GraffitiLocal());
 const graffiti = useGraffiti();
 
 const useSession1 = async () => {
@@ -32,7 +33,7 @@ describe.concurrent("synchronizeDiscover", () => {
 
     const object = randomPutObject();
     const channels = object.channels.slice(1);
-    const putted = await graffiti1.put(object, session);
+    const putted = await graffiti1.put<{}>(object, session);
 
     const graffiti2 = useGraffiti();
     const next = graffiti2.synchronizeDiscover(channels, {}).next();
@@ -55,7 +56,7 @@ describe.concurrent("synchronizeDiscover", () => {
 
     const oldValue = { hello: "world" };
     const oldChannels = [beforeChannel, sharedChannel];
-    const putted = await graffiti.put(
+    const putted = await graffiti.put<{}>(
       {
         value: oldValue,
         channels: oldChannels,
@@ -71,7 +72,7 @@ describe.concurrent("synchronizeDiscover", () => {
     // Replace the object
     const newValue = { goodbye: "world" };
     const newChannels = [afterChannel, sharedChannel];
-    await graffiti.put(
+    await graffiti.put<{}>(
       {
         ...putted,
         value: newValue,
@@ -118,7 +119,7 @@ describe.concurrent("synchronizeDiscover", () => {
 
     const oldValue = { hello: "world" };
     const oldChannels = [beforeChannel, sharedChannel];
-    const putted = await graffiti.put(
+    const putted = await graffiti.put<{}>(
       {
         value: oldValue,
         channels: oldChannels,
@@ -194,7 +195,7 @@ describe.concurrent("synchronizeDiscover", () => {
 
     const oldValue = { hello: "world" };
     const oldChannels = [randomString(), ...channels.slice(1)];
-    const putted = await graffiti.put(
+    const putted = await graffiti.put<{}>(
       {
         value: oldValue,
         channels: oldChannels,
@@ -223,7 +224,7 @@ describe.concurrent("synchronizeDiscover", () => {
 
     for (let i = 0; i < 10; i++) {
       const next = iterator.next();
-      const putted = graffiti.put(object, session);
+      const putted = graffiti.put<{}>(object, session);
 
       let first: undefined | string = undefined;
       next.then(() => {
@@ -282,10 +283,13 @@ describe.concurrent("synchronizeDiscover", () => {
       hello: "world",
     };
     const allowed = [randomString(), session2.actor];
-    await graffiti.put({ value, channels: allChannels, allowed }, session1);
+    await graffiti.put<{}>({ value, channels: allChannels, allowed }, session1);
 
     // Expect no session to time out!
     await expect(
+      // @ts-ignore - otherwise you might get
+      // "Type instantiation is excessively deep
+      //  and possibly infinite."
       Promise.race([
         noSession,
         new Promise((resolve, rejects) => setTimeout(rejects, 100, "Timeout")),
@@ -327,14 +331,14 @@ describe.concurrent("synchronizeGet", () => {
 
   it("replace, delete", async () => {
     const object = randomPutObject();
-    const putted = await graffiti.put(object, session);
+    const putted = await graffiti.put<{}>(object, session);
 
     const iterator = graffiti.synchronizeGet(putted, {});
     const next = iterator.next();
 
     // Change the object
     const newValue = { goodbye: "world" };
-    const putted2 = await graffiti.put(
+    const putted2 = await graffiti.put<{}>(
       {
         ...putted,
         value: newValue,
@@ -360,8 +364,11 @@ describe.concurrent("synchronizeGet", () => {
     expect(result2.value.lastModified).toEqual(deleted.lastModified);
 
     // Put something else
-    await graffiti.put(randomPutObject(), session);
+    await graffiti.put<{}>(randomPutObject(), session);
     await expect(
+      // @ts-ignore - otherwise you might get
+      // "Type instantiation is excessively deep
+      //  and possibly infinite."
       Promise.race([
         iterator.next(),
         new Promise((resolve, reject) => setTimeout(reject, 100, "Timeout")),
@@ -371,7 +378,7 @@ describe.concurrent("synchronizeGet", () => {
 
   it("not allowed", async () => {
     const object = randomPutObject();
-    const putted = await graffiti.put(object, session1);
+    const putted = await graffiti.put<{}>(object, session1);
 
     const iterator1 = graffiti.synchronizeGet(putted, {}, session1);
     const iterator2 = graffiti.synchronizeGet(putted, {}, session2);
@@ -380,7 +387,7 @@ describe.concurrent("synchronizeGet", () => {
     const next2 = iterator2.next();
 
     const newValue = { goodbye: "world" };
-    const putted2 = await graffiti.put(
+    const putted2 = await graffiti.put<{}>(
       {
         ...putted,
         ...object,
@@ -406,3 +413,59 @@ describe.concurrent("synchronizeGet", () => {
     expect(result2.value.lastModified).toEqual(putted2.lastModified);
   });
 });
+
+// can't be concurrent because it gets ALL
+describe("synchronizeAll", () => {
+  let session: GraffitiSession;
+  let session1: GraffitiSession;
+  let session2: GraffitiSession;
+  beforeAll(async () => {
+    session1 = await useSession1();
+    session = session1;
+    session2 = await useSession2();
+  });
+
+  it("sync from multiple channels and actors", async () => {
+    const object1 = randomPutObject();
+    const object2 = randomPutObject();
+
+    expect(object1.channels).not.toEqual(object2.channels);
+
+    const iterator = graffiti.synchronizeAll();
+
+    const next1 = iterator.next();
+    const next2 = iterator.next();
+
+    await graffiti.put<{}>(object1, session1);
+    await graffiti.put<{}>(object2, session2);
+
+    const result1 = (await next1).value;
+    const result2 = (await next2).value;
+    assert(result1 && !result1.error);
+    assert(result2 && !result2.error);
+
+    expect(result1.value.value).toEqual(object1.value);
+    expect(result1.value.channels).toEqual([]);
+    expect(result2.value.value).toEqual(object2.value);
+  });
+
+  it("omniscient", async () => {
+    const graffiti = new GraffitiSynchronize(new GraffitiLocal(), {
+      omniscient: true,
+    });
+
+    const object1 = randomPutObject();
+    object1.allowed = [randomString()];
+
+    const iterator = graffiti.synchronizeAll();
+    const next = iterator.next();
+
+    await graffiti.put<{}>(object1, session1);
+
+    const result = (await next).value;
+    assert(result && !result.error);
+    expect(result.value.value).toEqual(object1.value);
+    expect(result.value.channels).toEqual(object1.channels);
+    expect(result.value.allowed).toEqual(object1.allowed);
+  });
+});

package/src/index.ts

@@ -1,17 +1,17 @@
-import Ajv from "ajv-draft-04";
+import type Ajv from "ajv";
 import { Graffiti } from "@graffiti-garden/api";
 import type {
   GraffitiSession,
   GraffitiObject,
-  JSONSchema4,
+  JSONSchema,
   GraffitiStream,
 } from "@graffiti-garden/api";
 import type { GraffitiObjectBase } from "@graffiti-garden/api";
 import { Repeater } from "@repeaterjs/repeater";
-import { applyPatch } from "fast-json-patch";
+import type { applyPatch } from "fast-json-patch";
 import {
   applyGraffitiPatch,
-  attemptAjvCompile,
+  compileGraffitiObjectSchema,
   isActorAllowedGraffitiObject,
   locationToUri,
   maskGraffitiObject,
@@ -24,6 +24,20 @@ export type GraffitiSynchronizeCallback = (
   newObject?: GraffitiObjectBase,
 ) => void;
 
+export interface GraffitiSynchronizeOptions {
+  /**
+   * Allows synchronize to listen to all objects, not just those
+   * that the session is allowed to see. This is useful to get a
+   * global view of all Graffiti objects passsing through the system,
+   * for example to build a client-side cache. Additional mechanisms
+   * should be in place to ensure that users do not see objects or
+   * properties they are not allowed to see.
+   *
+   * Default: `false`
+   */
+  omniscient?: boolean;
+}
+
 /**
  * Wraps the [Graffiti API](https://api.graffiti.garden/classes/Graffiti.html)
  * so that changes made or received in one part of an application
@@ -67,9 +81,11 @@ export type GraffitiSynchronizeCallback = (
  * streams appropriate changes to provide a responsive and consistent user experience.
  */
 export class GraffitiSynchronize extends Graffiti {
-  protected readonly ajv: Ajv;
+  protected ajv_: Promise<Ajv> | undefined;
+  protected applyPatch_: Promise<typeof applyPatch> | undefined;
   protected readonly graffiti: Graffiti;
   protected readonly callbacks = new Set<GraffitiSynchronizeCallback>();
+  protected readonly options: GraffitiSynchronizeOptions;
 
   channelStats: Graffiti["channelStats"];
   locationToUri: Graffiti["locationToUri"];
@@ -78,6 +94,26 @@ export class GraffitiSynchronize extends Graffiti {
   logout: Graffiti["logout"];
   sessionEvents: Graffiti["sessionEvents"];
 
+  get ajv() {
+    if (!this.ajv_) {
+      this.ajv_ = (async () => {
+        const { default: Ajv } = await import("ajv");
+        return new Ajv({ strict: false });
+      })();
+    }
+    return this.ajv_;
+  }
+
+  get applyPatch() {
+    if (!this.applyPatch_) {
+      this.applyPatch_ = (async () => {
+        const { applyPatch } = await import("fast-json-patch");
+        return applyPatch;
+      })();
+    }
+    return this.applyPatch_;
+  }
+
   /**
    * Wraps a Graffiti API instance to provide the synchronize methods.
    * The GraffitiSyncrhonize class rather than the Graffiti class
@@ -89,15 +125,10 @@ export class GraffitiSynchronize extends Graffiti {
      * instance to wrap.
      */
     graffiti: Graffiti,
-    /**
-     * An optional instance of Ajv to use for validating
-     * objects before dispatching them to listeners.
-     * If not provided, a new instance of Ajv will be created.
-     */
-    ajv?: Ajv,
+    options?: GraffitiSynchronizeOptions,
   ) {
     super();
-    this.ajv = ajv ?? new Ajv({ strict: false });
+    this.options = options ?? {};
     this.graffiti = graffiti;
     this.channelStats = graffiti.channelStats.bind(graffiti);
     this.locationToUri = graffiti.locationToUri.bind(graffiti);
@@ -107,16 +138,15 @@ export class GraffitiSynchronize extends Graffiti {
     this.sessionEvents = graffiti.sessionEvents;
   }
 
-  protected synchronize<Schema extends JSONSchema4>(
+  protected synchronize<Schema extends JSONSchema>(
     matchObject: (object: GraffitiObjectBase) => boolean,
     channels: string[],
     schema: Schema,
     session?: GraffitiSession | null,
   ) {
-    const validate = attemptAjvCompile(this.ajv, schema);
-
     const repeater: GraffitiStream<GraffitiObject<Schema>> = new Repeater(
       async (push, stop) => {
+        const validate = compileGraffitiObjectSchema(await this.ajv, schema);
         const callback: GraffitiSynchronizeCallback = (
           oldObjectRaw,
           newObjectRaw,
@@ -125,10 +155,13 @@ export class GraffitiSynchronize extends Graffiti {
             if (
               objectRaw &&
               matchObject(objectRaw) &&
-              isActorAllowedGraffitiObject(objectRaw, session)
+              (this.options.omniscient ||
+                isActorAllowedGraffitiObject(objectRaw, session))
             ) {
               const object = { ...objectRaw };
-              maskGraffitiObject(object, channels, session);
+              if (!this.options.omniscient) {
+                maskGraffitiObject(object, channels, session);
+              }
               if (validate(object)) {
                 push({ value: object });
                 break;
@@ -159,14 +192,14 @@ export class GraffitiSynchronize extends Graffiti {
    *
    * @group Synchronize Methods
    */
-  synchronizeDiscover<Schema extends JSONSchema4>(
+  synchronizeDiscover<Schema extends JSONSchema>(
     ...args: Parameters<typeof Graffiti.prototype.discover<Schema>>
   ): GraffitiStream<GraffitiObject<Schema>> {
     const [channels, schema, session] = args;
     function matchObject(object: GraffitiObjectBase) {
       return object.channels.some((channel) => channels.includes(channel));
     }
-    return this.synchronize(matchObject, channels, schema, session);
+    return this.synchronize<Schema>(matchObject, channels, schema, session);
   }
 
   /**
@@ -180,7 +213,7 @@ export class GraffitiSynchronize extends Graffiti {
    *
    * @group Synchronize Methods
    */
-  synchronizeGet<Schema extends JSONSchema4>(
+  synchronizeGet<Schema extends JSONSchema>(
     ...args: Parameters<typeof Graffiti.prototype.get<Schema>>
   ): GraffitiStream<GraffitiObject<Schema>> {
     const [locationOrUri, schema, session] = args;
@@ -189,7 +222,7 @@ export class GraffitiSynchronize extends Graffiti {
       const { uri } = unpackLocationOrUri(locationOrUri);
       return objectUri === uri;
     }
-    return this.synchronize(matchObject, [], schema, session);
+    return this.synchronize<Schema>(matchObject, [], schema, session);
   }
 
   /**
@@ -205,14 +238,31 @@ export class GraffitiSynchronize extends Graffiti {
    *
    * @group Synchronize Methods
    */
-  synchronizeRecoverOrphans<Schema extends JSONSchema4>(
+  synchronizeRecoverOrphans<Schema extends JSONSchema>(
     ...args: Parameters<typeof Graffiti.prototype.recoverOrphans<Schema>>
   ): GraffitiStream<GraffitiObject<Schema>> {
     const [schema, session] = args;
     function matchObject(object: GraffitiObjectBase) {
       return object.actor === session.actor && object.channels.length === 0;
     }
-    return this.synchronize(matchObject, [], schema, session);
+    return this.synchronize<Schema>(matchObject, [], schema, session);
+  }
+
+  /**
+   * Streams changes made to *any* object in *any* channel
+   * and made by *any* user. You may want to use it in conjuction with
+   * {@link GraffitiSyncrhonizeOptions.omniscient} to get a global view
+   * of all Graffiti objects passing through the system. This is useful
+   * for building a client-side cache, for example.
+   *
+   * Be careful using this method. Without additional filters it can
+   * expose the user to content out of context.
+   */
+  synchronizeAll(
+    schema?: JSONSchema,
+    session?: GraffitiSession | null,
+  ): GraffitiStream<GraffitiObjectBase> {
+    return this.synchronize(() => true, [], schema ?? {}, session);
   }
 
   protected async synchronizeDispatch(
@@ -255,7 +305,7 @@ export class GraffitiSynchronize extends Graffiti {
   };
 
   put: Graffiti["put"] = async (...args) => {
-    const oldObject = await this.graffiti.put(...args);
+    const oldObject = await this.graffiti.put<{}>(...args);
     const partialObject = args[0];
     const newObject: GraffitiObjectBase = {
       ...oldObject,
@@ -273,7 +323,7 @@ export class GraffitiSynchronize extends Graffiti {
     const newObject: GraffitiObjectBase = { ...oldObject };
     newObject.tombstone = false;
     for (const prop of ["value", "channels", "allowed"] as const) {
-      applyGraffitiPatch(applyPatch, prop, args[0], newObject);
+      applyGraffitiPatch(await this.applyPatch, prop, args[0], newObject);
     }
     await this.synchronizeDispatch(oldObject, newObject, true);
     return oldObject;
@@ -285,7 +335,7 @@ export class GraffitiSynchronize extends Graffiti {
     return oldObject;
   };
 
-  protected objectStream<Schema extends JSONSchema4>(
+  protected objectStream<Schema extends JSONSchema>(
     iterator: ReturnType<typeof Graffiti.prototype.discover<Schema>>,
   ) {
     const dispatch = this.synchronizeDispatch.bind(this);
@@ -305,11 +355,11 @@ export class GraffitiSynchronize extends Graffiti {
 
   discover: Graffiti["discover"] = (...args) => {
     const iterator = this.graffiti.discover(...args);
-    return this.objectStream(iterator);
+    return this.objectStream<(typeof args)[1]>(iterator);
   };
 
   recoverOrphans: Graffiti["recoverOrphans"] = (...args) => {
     const iterator = this.graffiti.recoverOrphans(...args);
-    return this.objectStream(iterator);
+    return this.objectStream<(typeof args)[0]>(iterator);
   };
 }