@cedarjs/realtime 0.0.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Cedar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,61 @@
+# Realtime
+
+The real-time solution for RedwoodJS is initially for GraphQL.
+
+In GraphQL, there are two options for real-time updates: **live queries** and **subscriptions**. Subscriptions are part of the GraphQL specification, whereas live queries are not.
+
+There are times where subscriptions are well-suited for a realtime problem — and in some cases live queries may be a better fit. Later we’ll explore the pros and cons of each approach and how best to decide that to use and when.
+
+### Features
+
+RedwoodJS Realtime handles the hard parts of a GraphQL Realtime implementation by automatically:
+
+- allowing GraphQL Subscription operations to be handled
+- merging in your subscriptions types and mapping their handler functions (subscribe, and resolve) to your GraphQL schema letting you keep your subscription logic organized and apart from services (your subscription my use a service to respond to an event)
+- authenticating subscription requests using the same `@requireAuth` directives already protecting other queries and mutations (or you can implement your own validator directive)
+- adding in the `@live` query directive to your GraphQL schema and setting up the `useLiveQuery` envelop plugin to handle requests, invalidation, and managing the storage mechanism needed
+- creating and configuring in-memory and persisted Redis stores uses by the PubSub transport for subscriptions and Live Queries (and letting you switch between them in development and production)
+- placing the pubSub transport and stores into the GraphQL context so you can use them in services, subscription resolvers, or elsewhere (like a webhook, function, or job) to publish an event or invalidate data
+- typing you subscription channel event payloads
+
+It provides a first-class developer experience for real-time updates with GraphQL so you can easily
+
+- respond to an event (e.g. NewPost, NewUserNotification)
+- respond to a data change (e.g. Post 123's title updated)
+
+and have the latest data reflected in your app.
+
+Lastly, the Redwood CLI has commands to
+
+- generate a boilerplate implementation and sample code needed to create your custom
+  - subscriptions
+  - live Queries
+
+Regardless of the implementation chosen, **a stateful server and store are needed** to track changes, invalidation, or who wants to be informed about the change.
+
+### useRedwoodRealtime
+
+The `useRedwoodRealtime` plugin adds support for Redwood Realtime in GraphQL Yoga Server.
+
+Note: Since a stateful server and store are needed, this plugin cannot be used this RedwoodJS applications deployed to serverless.
+
+> **Warning**
+>
+> This is a new internal package. There are still changes we want to make, so we're marking it as experimental for now.
+> **Don't depend on this directly in a Redwood project**.
+
+<!-- ## Package size
+
+| Version                                                                            | Publish | Install |
+| :--------------------------------------------------------------------------------- | :------ | :------ |
+| [v5.2.1](https://packagephobia.com/result?p=%40redwoodjs%2Fproject-config%405.2.1) | 96.6 kB | 809 kB  |
+
+## Dependency graphs
+
+### src
+
+![src](./dependencyGraph.src.svg)
+
+### dist
+
+![dist](./dependencyGraph.dist.svg) -->

package/dist/graphql/index.d.ts

@@ -0,0 +1,3 @@
+export { useRedwoodRealtime, createPubSub, liveDirectiveTypeDefs, InMemoryLiveQueryStore, RedisLiveQueryStore, liveQueryStore, pubSub, Repeater, } from './plugins/useRedwoodRealtime';
+export type { LiveQueryStorageMechanism, PubSub, PublishClientType, SubscribeClientType, SubscriptionGlobImports, RedwoodRealtimeOptions, } from './plugins/useRedwoodRealtime';
+//# sourceMappingURL=index.d.ts.map

package/dist/graphql/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/graphql/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,YAAY,EACZ,qBAAqB,EACrB,sBAAsB,EACtB,mBAAmB,EACnB,cAAc,EACd,MAAM,EACN,QAAQ,GACT,MAAM,8BAA8B,CAAA;AAErC,YAAY,EACV,yBAAyB,EACzB,MAAM,EACN,iBAAiB,EACjB,mBAAmB,EACnB,uBAAuB,EACvB,sBAAsB,GACvB,MAAM,8BAA8B,CAAA"}

package/dist/graphql/plugins/__fixtures__/common.d.ts

@@ -0,0 +1,9 @@
+export declare const testSchema: import("graphql").GraphQLSchema;
+export declare const testLiveSchema: import("graphql").GraphQLSchema;
+export declare const testQuery = "\n  query meQuery {\n    me {\n      id\n      name\n    }\n  }\n";
+export declare const testFilteredQuery = "\n  query FilteredQuery {\n    me {\n      id\n      name\n    }\n  }\n";
+export declare const testErrorQuery = "\n  query forbiddenUserQuery {\n    forbiddenUser {\n      id\n      name\n    }\n  }\n";
+export declare const testLiveQuery = "\n  query meQuery @live {\n    me {\n      id\n      name\n    }\n  }\n";
+export declare const testParseErrorQuery = "\n  query ParseErrorQuery {\n    me {\n      id\n      name\n      unknown_field\n    }\n  }\n";
+export declare const testValidationErrorQuery = "\n  query ValidationErrorQuery(id: Int!) {\n    getUser(id: 'one') {\n      id\n      name\n    }\n  }\n";
+//# sourceMappingURL=common.d.ts.map

package/dist/graphql/plugins/__fixtures__/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../../src/graphql/plugins/__fixtures__/common.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,UAAU,iCAiCrB,CAAA;AAEF,eAAO,MAAM,cAAc,iCAgDzB,CAAA;AACF,eAAO,MAAM,SAAS,sEAOrB,CAAA;AAED,eAAO,MAAM,iBAAiB,4EAO7B,CAAA;AAED,eAAO,MAAM,cAAc,4FAO1B,CAAA;AAED,eAAO,MAAM,aAAa,4EAOzB,CAAA;AAED,eAAO,MAAM,mBAAmB,mGAQ/B,CAAA;AAED,eAAO,MAAM,wBAAwB,6GAOpC,CAAA"}

package/dist/graphql/plugins/useRedwoodRealtime.d.ts

@@ -0,0 +1,94 @@
+import type { Plugin } from '@envelop/core';
+import type { CreateRedisEventTargetArgs } from '@graphql-yoga/redis-event-target';
+import type { PubSub } from '@graphql-yoga/subscription';
+import { createPubSub } from '@graphql-yoga/subscription';
+import { InMemoryLiveQueryStore } from '@n1ru4l/in-memory-live-query-store';
+import type { execute as defaultExecute } from 'graphql';
+export { Repeater } from 'graphql-yoga';
+/**
+ * We want SubscriptionsGlobs type to be an object with this shape:
+ *
+ * But not fully supported in TS
+ * {
+ *   schema: DocumentNode // <-- required
+ *   [string]: RedwoodSubscription
+ * }
+ *
+ * Note: This type is duplicated from packages/graphql-server/src/subscriptions/makeSubscriptions
+ * so there is no dependency on graphql-server from realtime and vice versa.
+ */
+export type SubscriptionGlobImports = Record<string, any>;
+export type { PubSub };
+export { createPubSub, InMemoryLiveQueryStore };
+export declare const liveDirectiveTypeDefs: string;
+export type LiveQueryStorageMechanism = RedisLiveQueryStore | InMemoryLiveQueryStore;
+export type PublishClientType = CreateRedisEventTargetArgs['publishClient'];
+export type SubscribeClientType = CreateRedisEventTargetArgs['subscribeClient'];
+/**
+ * Configure RedwoodJS Realtime
+ *
+ * Realtime supports Live Queries and Subscriptions over GraphQL SSE.
+ *
+ * Live Queries are GraphQL queries that are automatically re-run when the data they depend on changes.
+ *
+ * Subscriptions are GraphQL queries that are run when a client subscribes to a channel.
+ *
+ * Redwood Realtime
+ *  - uses a publish/subscribe model to broadcast data to clients.
+ *  - uses a store to persist Live Query and Subscription data.
+ *
+ * Redwood Realtime supports in-memory and Redis stores:
+ * - In-memory stores are useful for development and testing.
+ * - Redis stores are useful for production.
+ *
+ */
+export type RedwoodRealtimeOptions = {
+    enableDeferStream?: boolean;
+    liveQueries?: {
+        /**
+         * @description Redwood Realtime supports in-memory and Redis stores.
+         * @default 'in-memory'
+         */
+        store: 'in-memory' | {
+            redis: {
+                /**
+                 * @description The channel to publish invalidations to.
+                 * @default 'live-query-invalidations'
+                 */
+                channel?: string;
+                publishClient: PublishClientType;
+                subscribeClient: SubscribeClientType;
+            };
+        };
+    };
+    subscriptions?: {
+        /**
+         * @description Redwood Realtime supports in-memory and Redis stores.
+         * @default 'in-memory'
+         */
+        store: 'in-memory' | {
+            redis: {
+                publishClient: PublishClientType;
+                subscribeClient: SubscribeClientType;
+            };
+        };
+        /**
+         * @description Subscriptions passed from the glob import:
+         * import subscriptions from 'src/subscriptions/**\/*.{js,ts}'
+         */
+        subscriptions: SubscriptionGlobImports;
+    };
+};
+export declare class RedisLiveQueryStore {
+    pub: PublishClientType;
+    sub: SubscribeClientType;
+    channel: string;
+    liveQueryStore: InMemoryLiveQueryStore;
+    constructor(pub: PublishClientType, sub: SubscribeClientType, channel: string, liveQueryStore: InMemoryLiveQueryStore);
+    invalidate(identifiers: string[] | string): Promise<void>;
+    makeExecute(execute: typeof defaultExecute): (args: import("graphql").ExecutionArgs) => AsyncIterableIterator<import("graphql").ExecutionResult<import("graphql/jsutils/ObjMap").ObjMap<unknown>, import("graphql/jsutils/ObjMap").ObjMap<unknown>> | import("@n1ru4l/graphql-live-query").LiveExecutionResult> | import("graphql").ExecutionResult<import("graphql/jsutils/ObjMap").ObjMap<unknown>, import("graphql/jsutils/ObjMap").ObjMap<unknown>> | Promise<AsyncIterableIterator<import("graphql").ExecutionResult<import("graphql/jsutils/ObjMap").ObjMap<unknown>, import("graphql/jsutils/ObjMap").ObjMap<unknown>> | import("@n1ru4l/graphql-live-query").LiveExecutionResult> | import("graphql").ExecutionResult<import("graphql/jsutils/ObjMap").ObjMap<unknown>, import("graphql/jsutils/ObjMap").ObjMap<unknown>>>;
+}
+export declare let liveQueryStore: LiveQueryStorageMechanism | undefined;
+export declare let pubSub: ReturnType<typeof createPubSub> | undefined;
+export declare const useRedwoodRealtime: (options: RedwoodRealtimeOptions) => Plugin;
+//# sourceMappingURL=useRedwoodRealtime.d.ts.map

package/dist/graphql/plugins/useRedwoodRealtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRedwoodRealtime.d.ts","sourceRoot":"","sources":["../../../src/graphql/plugins/useRedwoodRealtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAO3C,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,kCAAkC,CAAA;AAClF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAA;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAEzD,OAAO,EAAE,sBAAsB,EAAE,MAAM,oCAAoC,CAAA;AAC3E,OAAO,KAAK,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,SAAS,CAAA;AAGxD,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAEvC;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,uBAAuB,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;AAEzD,YAAY,EAAE,MAAM,EAAE,CAAA;AAEtB,OAAO,EAAE,YAAY,EAAE,sBAAsB,EAAE,CAAA;AAE/C,eAAO,MAAM,qBAAqB,QAEjC,CAAA;AAED,MAAM,MAAM,yBAAyB,GACjC,mBAAmB,GACnB,sBAAsB,CAAA;AAE1B,MAAM,MAAM,iBAAiB,GAAG,0BAA0B,CAAC,eAAe,CAAC,CAAA;AAC3E,MAAM,MAAM,mBAAmB,GAAG,0BAA0B,CAAC,iBAAiB,CAAC,CAAA;AAE/E;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,WAAW,CAAC,EAAE;QACZ;;;WAGG;QACH,KAAK,EACD,WAAW,GACX;YACE,KAAK,EAAE;gBACL;;;mBAGG;gBACH,OAAO,CAAC,EAAE,MAAM,CAAA;gBAChB,aAAa,EAAE,iBAAiB,CAAA;gBAChC,eAAe,EAAE,mBAAmB,CAAA;aACrC,CAAA;SACF,CAAA;KACN,CAAA;IACD,aAAa,CAAC,EAAE;QACd;;;WAGG;QACH,KAAK,EACD,WAAW,GACX;YACE,KAAK,EAAE;gBACL,aAAa,EAAE,iBAAiB,CAAA;gBAChC,eAAe,EAAE,mBAAmB,CAAA;aACrC,CAAA;SACF,CAAA;QACL;;;WAGG;QACH,aAAa,EAAE,uBAAuB,CAAA;KACvC,CAAA;CACF,CAAA;AAED,qBAAa,mBAAmB;IAC9B,GAAG,EAAE,iBAAiB,CAAA;IACtB,GAAG,EAAE,mBAAmB,CAAA;IACxB,OAAO,EAAE,MAAM,CAAA;IACf,cAAc,EAAE,sBAAsB,CAAA;gBAGpC,GAAG,EAAE,iBAAiB,EACtB,GAAG,EAAE,mBAAmB,EACxB,OAAO,EAAE,MAAM,EACf,cAAc,EAAE,sBAAsB;IAoBlC,UAAU,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,MAAM;IAS/C,WAAW,CAAC,OAAO,EAAE,OAAO,cAAc;CAG3C;AAGD,eAAO,IAAI,cAAc,EAAE,yBAAyB,GAAG,SAAqB,CAAA;AAC5E,eAAO,IAAI,MAAM,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,GAAG,SAAqB,CAAA;AAE1E,eAAO,MAAM,kBAAkB,YAAa,sBAAsB,KAAG,MAiGpE,CAAA"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { useRedwoodRealtime, createPubSub, liveDirectiveTypeDefs, InMemoryLiveQueryStore, RedisLiveQueryStore, liveQueryStore, pubSub, Repeater, } from './graphql';
+export type { LiveQueryStorageMechanism, PubSub, PublishClientType, SubscribeClientType, SubscriptionGlobImports, RedwoodRealtimeOptions, } from './graphql';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,YAAY,EACZ,qBAAqB,EACrB,sBAAsB,EACtB,mBAAmB,EACnB,cAAc,EACd,MAAM,EACN,QAAQ,GACT,MAAM,WAAW,CAAA;AAElB,YAAY,EACV,yBAAyB,EACzB,MAAM,EACN,iBAAiB,EACjB,mBAAmB,EACnB,uBAAuB,EACvB,sBAAsB,GACvB,MAAM,WAAW,CAAA"}

package/dist/index.js

@@ -0,0 +1,175 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  InMemoryLiveQueryStore: () => import_in_memory_live_query_store.InMemoryLiveQueryStore,
+  RedisLiveQueryStore: () => RedisLiveQueryStore,
+  Repeater: () => import_graphql_yoga.Repeater,
+  createPubSub: () => import_subscription.createPubSub,
+  liveDirectiveTypeDefs: () => liveDirectiveTypeDefs,
+  liveQueryStore: () => liveQueryStore,
+  pubSub: () => pubSub,
+  useRedwoodRealtime: () => useRedwoodRealtime
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/graphql/plugins/useRedwoodRealtime.ts
+var import_live_query = require("@envelop/live-query");
+var import_schema = require("@graphql-tools/schema");
+var import_utils = require("@graphql-tools/utils");
+var import_plugin_defer_stream = require("@graphql-yoga/plugin-defer-stream");
+var import_plugin_graphql_sse = require("@graphql-yoga/plugin-graphql-sse");
+var import_redis_event_target = require("@graphql-yoga/redis-event-target");
+var import_subscription = require("@graphql-yoga/subscription");
+var import_graphql_live_query = require("@n1ru4l/graphql-live-query");
+var import_in_memory_live_query_store = require("@n1ru4l/in-memory-live-query-store");
+var import_graphql = require("graphql");
+var import_graphql_yoga = require("graphql-yoga");
+var liveDirectiveTypeDefs = (0, import_graphql.print)(
+  (0, import_utils.astFromDirective)(import_graphql_live_query.GraphQLLiveDirective)
+);
+var RedisLiveQueryStore = class {
+  pub;
+  sub;
+  channel;
+  liveQueryStore;
+  constructor(pub, sub, channel, liveQueryStore2) {
+    this.pub = pub;
+    this.sub = sub;
+    this.liveQueryStore = liveQueryStore2;
+    this.channel = channel;
+    this.sub.subscribe(this.channel, (err) => {
+      if (err) {
+        throw err;
+      }
+    });
+    this.sub.on("message", (channel2, resourceIdentifier) => {
+      if (channel2 === this.channel && resourceIdentifier) {
+        this.liveQueryStore.invalidate(resourceIdentifier);
+      }
+    });
+  }
+  async invalidate(identifiers) {
+    if (typeof identifiers === "string") {
+      identifiers = [identifiers];
+    }
+    for (const identifier of identifiers) {
+      this.pub.publish(this.channel, identifier);
+    }
+  }
+  makeExecute(execute) {
+    return this.liveQueryStore.makeExecute(execute);
+  }
+};
+var liveQueryStore = void 0;
+var pubSub = void 0;
+var useRedwoodRealtime = (options) => {
+  let liveQueriesEnabled = false;
+  let subscriptionsEnabled = false;
+  let liveQueryPlugin = {};
+  const inMemoryLiveQueryStore = new import_in_memory_live_query_store.InMemoryLiveQueryStore();
+  liveQueryStore = {};
+  pubSub = {};
+  const wasLiveQueryAdded = Symbol.for("useRedwoodRealtime.wasLiveQueryAdded");
+  if (options.liveQueries?.store) {
+    if (options.liveQueries.store === "in-memory") {
+      liveQueriesEnabled = true;
+      liveQueryStore = inMemoryLiveQueryStore;
+      liveQueryPlugin = (0, import_live_query.useLiveQuery)({
+        liveQueryStore
+      });
+    } else if (options.liveQueries.store.redis) {
+      liveQueriesEnabled = true;
+      liveQueryStore = new RedisLiveQueryStore(
+        options.liveQueries.store.redis.publishClient,
+        options.liveQueries.store.redis.subscribeClient,
+        options.liveQueries.store.redis.channel || "live-query-invalidations",
+        inMemoryLiveQueryStore
+      );
+      liveQueryPlugin = (0, import_live_query.useLiveQuery)({
+        liveQueryStore
+      });
+    } else {
+      throw new Error("Invalid live query store configuration.");
+    }
+  }
+  if (options.subscriptions) {
+    if (options.subscriptions.store === "in-memory") {
+      subscriptionsEnabled = true;
+      pubSub = (0, import_subscription.createPubSub)();
+    } else if (options.subscriptions.store.redis) {
+      subscriptionsEnabled = true;
+      const eventTarget = (0, import_redis_event_target.createRedisEventTarget)({
+        publishClient: options.subscriptions.store.redis.publishClient,
+        subscribeClient: options.subscriptions.store.redis.subscribeClient
+      });
+      pubSub = (0, import_subscription.createPubSub)({ eventTarget });
+    }
+  }
+  return {
+    onSchemaChange({ replaceSchema, schema }) {
+      if (schema.extensions?.[wasLiveQueryAdded] === true) {
+        return;
+      }
+      if (liveQueriesEnabled) {
+        const liveSchema = (0, import_schema.mergeSchemas)({
+          schemas: [schema],
+          typeDefs: [liveDirectiveTypeDefs]
+        });
+        liveSchema.extensions = {
+          ...schema.extensions,
+          [wasLiveQueryAdded]: true
+        };
+        replaceSchema(liveSchema);
+      }
+    },
+    onPluginInit({ addPlugin }) {
+      if (liveQueriesEnabled) {
+        addPlugin(liveQueryPlugin);
+      }
+      if (subscriptionsEnabled) {
+        addPlugin((0, import_plugin_graphql_sse.useGraphQLSSE)());
+      }
+      if (options.enableDeferStream) {
+        addPlugin((0, import_plugin_defer_stream.useDeferStream)());
+      }
+    },
+    onContextBuilding() {
+      return ({ extendContext }) => {
+        extendContext({
+          liveQueryStore: liveQueriesEnabled && liveQueryStore,
+          pubSub: subscriptionsEnabled && pubSub
+        });
+      };
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InMemoryLiveQueryStore,
+  RedisLiveQueryStore,
+  Repeater,
+  createPubSub,
+  liveDirectiveTypeDefs,
+  liveQueryStore,
+  pubSub,
+  useRedwoodRealtime
+});

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@cedarjs/realtime",
+  "version": "0.0.4",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cedarjs/cedar.git",
+    "directory": "packages/realtime"
+  },
+  "license": "MIT",
+  "exports": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsx ./build.mts && run build:types",
+    "build:pack": "yarn pack -o cedar-realtime.tgz",
+    "build:types": "tsc --build --verbose",
+    "build:watch": "nodemon --watch src --ext \"js,ts,tsx\" --ignore dist --exec \"yarn build\"",
+    "prepublishOnly": "NODE_ENV=production yarn build",
+    "test": "vitest run",
+    "test:watch": "vitest watch"
+  },
+  "dependencies": {
+    "@envelop/live-query": "7.0.0",
+    "@graphql-tools/schema": "10.0.6",
+    "@graphql-tools/utils": "10.5.4",
+    "@graphql-yoga/plugin-defer-stream": "3.7.0",
+    "@graphql-yoga/plugin-graphql-sse": "3.7.0",
+    "@graphql-yoga/redis-event-target": "3.0.1",
+    "@graphql-yoga/subscription": "5.0.1",
+    "@n1ru4l/graphql-live-query": "0.10.0",
+    "@n1ru4l/in-memory-live-query-store": "0.10.0",
+    "graphql": "16.9.0"
+  },
+  "devDependencies": {
+    "@cedarjs/framework-tools": "0.0.4",
+    "@envelop/core": "5.0.2",
+    "@envelop/testing": "7.0.0",
+    "@envelop/types": "5.0.0",
+    "ioredis": "5.6.0",
+    "nodemon": "3.1.9",
+    "tsx": "4.19.3",
+    "typescript": "5.6.2",
+    "vitest": "2.1.9"
+  },
+  "peerDependencies": {
+    "ioredis": "^5.3.2"
+  },
+  "peerDependenciesMeta": {
+    "ioredis": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "5b4f77f985bd86ee31ee7338312627accf0cb85b"
+}