@baeta/subscriptions-pubsub 2.0.0-next.2 → 2.0.0-next.7

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @baeta/subscriptions-pubsub
 
+## 2.0.0-next.7
+
+## 2.0.0-next.6
+
+### Patch Changes
+
+- Fix export for subscriptions-pubsub
+
 ## 2.0.0-next.2
 
 ### Patch Changes

package/README.md

@@ -77,43 +77,68 @@ type Query {
 #### 2. Implement your resolvers
 
 ```typescript
-import { getUserModule } from "./typedef";
+import { UserModule } from "./typedef.ts";
 
-const { Query } = getUserModule();
+const { Query } = UserModule;
 
-Query.user(({ args }) => {
+const userQuery = Query.user.resolve(({ args }) => {
   return dataSource.user.find(args.where);
 });
 
-Query.users(() => {
+const usersQuery = Query.users.resolve(() => {
   return dataSource.user.findMany();
 });
+
+Query.$fields({
+  user: userQuery,
+  users: usersQuery,
+});
 ```
 
 #### 3. Add authorization
 
 ```typescript
-const { Query, Mutation } = getUserModule();
-
-Query.users.$auth({
-  $or: {
-    isPublic: true,
-    isLoggedIn: true,
-  },
-});
+import { UserModule } from "./typedef.ts";
+
+const { Query } = UserModule;
+
+const userQuery = Query.user
+  .auth({
+    $or: {
+      isPublic: true,
+      isLoggedIn: true,
+    },
+  })
+  .resolve(async ({ args }) => {
+    // ...
+  });
 ```
 
 #### 4. Add caching
 
 ```typescript
-import { getUserModule } from "./typedef";
-
-const { User, Query } = getUserModule();
+const { Query, Mutation, User } = UserModule;
 
 export const userCache = User.$createCache();
 
-Query.user.$useCache(userCache);
-Query.users.$useCache(userCache);
+const userQuery = Query.user
+  .auth({
+    // ...
+  })
+  .useCache(userCache)
+  .resolve(async ({ args }) => {
+    // ...
+  });
+
+const updateUserMutation = Mutation.updateUser
+  .$use(async (next) => {
+    const user = await next();
+    await userCache.save(user);
+    return user;
+  })
+  .resolve(async ({ args }) => {
+    // ...
+  });
 ```
 
 ## Compatibility

package/dist/index.d.ts

@@ -1,25 +1,26 @@
-type Any$1 = any;
+//#region lib/pubsub-engine.d.ts
+/** biome-ignore-all lint/suspicious/noExplicitAny: allow any args*/
 interface PubSubEngine {
-    publish: (triggerName: string, payload: Any$1, ...rest: Any$1[]) => Promise<void>;
-    subscribe: (triggerName: string, onMessage: (message: Any$1) => Promise<void> | void, ...rest: Any$1[]) => Promise<number>;
-    unsubscribe: (subId: number, ...rest: Any$1[]) => void;
-    asyncIterableIterator: <T>(triggers: string | readonly string[], ...rest: Any$1[]) => AsyncIterableIterator<T>;
+  publish: (triggerName: string, payload: any, ...rest: any[]) => Promise<void>;
+  subscribe: (triggerName: string, onMessage: (message: any) => Promise<void> | void, ...rest: any[]) => Promise<number>;
+  unsubscribe: (subId: number, ...rest: any[]) => void;
+  asyncIterableIterator: <T>(triggers: string | readonly string[], ...rest: any[]) => AsyncIterableIterator<T>;
 }
-
+//#endregion
+//#region lib/typed-pubsub.d.ts
 /**
  * Configuration options for TypedPubSub
  */
 interface TypedPubSubOptions {
-    /** Optional prefix for channel names */
-    prefix?: string;
+  /** Optional prefix for channel names */
+  prefix?: string;
 }
-type Any = any;
-type PubSubMap = Record<string, Any>;
+type PubSubMap = Record<string, any>;
 type OnMessage<Payload> = (message: Payload) => Promise<void> | void;
-type RestPayloadFnArgs<Fn> = Fn extends (triggerName: string, payload: Any, ...rest: infer Rest) => Any ? Rest : never;
-type RestSubscribeFnArgs<Fn> = Fn extends (triggerName: string, onMessage: OnMessage<Any>, ...rest: infer Rest) => Any ? Rest : never;
-type RestUnsubscribeFnArgs<Fn> = Fn extends (subId: number, ...rest: infer Rest) => Any ? Rest : never;
-type RestAsyncIterableIteratorFnArgs<Fn> = Fn extends (triggers: string | readonly string[], ...rest: infer Rest) => Any ? Rest : never;
+type RestPayloadFnArgs<Fn> = Fn extends ((triggerName: string, payload: any, ...rest: infer Rest) => any) ? Rest : never;
+type RestSubscribeFnArgs<Fn> = Fn extends ((triggerName: string, onMessage: OnMessage<any>, ...rest: infer Rest) => any) ? Rest : never;
+type RestUnsubscribeFnArgs<Fn> = Fn extends ((subId: number, ...rest: infer Rest) => any) ? Rest : never;
+type RestAsyncIterableIteratorFnArgs<Fn> = Fn extends ((triggers: string | readonly string[], ...rest: infer Rest) => any) ? Rest : never;
 /**
  * Creates a type-safe wrapper around a PubSub implementation.
  *
@@ -53,16 +54,17 @@ type RestAsyncIterableIteratorFnArgs<Fn> = Fn extends (triggers: string | readon
  * ```
  */
 declare class TypedPubSub<Engine extends PubSubEngine, Map extends PubSubMap> {
-    protected channelPrefix: string;
-    protected pubsub: Engine;
-    protected options?: TypedPubSubOptions;
-    constructor(pubsub: Engine, options?: TypedPubSubOptions);
-    publish: <C extends keyof Map>(channel: C, message: Map[C], ...rest: RestPayloadFnArgs<Engine["publish"]>) => Promise<void>;
-    subscribe: <C extends keyof Map>(channel: C, onMessage: OnMessage<Map[C]>, ...rest: RestSubscribeFnArgs<Engine["subscribe"]>) => Promise<number>;
-    unsubscribe: (subId: number, ...rest: RestUnsubscribeFnArgs<Engine["unsubscribe"]>) => void;
-    asyncIterableIterator: <C extends keyof Map>(triggers: C | C[], ...rest: RestAsyncIterableIteratorFnArgs<Engine["asyncIterableIterator"]>) => AsyncIterableIterator<Map[C]>;
-    protected mapChannel: <C extends keyof Map>(channel: C) => string;
-    protected mapTriggers: <C extends keyof Map>(triggers: C | C[]) => string | string[];
+  protected channelPrefix: string;
+  protected pubsub: Engine;
+  protected options?: TypedPubSubOptions;
+  constructor(pubsub: Engine, options?: TypedPubSubOptions);
+  publish: <C extends keyof Map>(channel: C, message: Map[C], ...rest: RestPayloadFnArgs<Engine["publish"]>) => Promise<void>;
+  subscribe: <C extends keyof Map>(channel: C, onMessage: OnMessage<Map[C]>, ...rest: RestSubscribeFnArgs<Engine["subscribe"]>) => Promise<number>;
+  unsubscribe: (subId: number, ...rest: RestUnsubscribeFnArgs<Engine["unsubscribe"]>) => void;
+  asyncIterableIterator: <C extends keyof Map>(triggers: C | C[], ...rest: RestAsyncIterableIteratorFnArgs<Engine["asyncIterableIterator"]>) => AsyncIterableIterator<Map[C]>;
+  protected mapChannel: <C extends keyof Map>(channel: C) => string;
+  protected mapTriggers: <C extends keyof Map>(triggers: C | C[]) => string | string[];
 }
-
+//#endregion
 export { TypedPubSub, type TypedPubSubOptions };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1 +1,65 @@
+//#region lib/typed-pubsub.ts
+/**
+* Creates a type-safe wrapper around a PubSub implementation.
+*
+* This utility ensures that your subscription channels and their payloads
+* are properly typed, helping catch potential errors at compile time.
+*
+* @param pubsub - The PubSub engine instance (e.g., PubSub, RedisPubSub)
+* @param options - Configuration options
+*
+* @example
+* ```typescript
+* // Define your event map
+* type PubSubMap = {
+*   "user-updated": User;
+*   [c: `user-updated-${string}`]: User;
+* };
+*
+* // Create typed PubSub instance
+* const pubsub = new TypedPubSub<PubSub, PubSubMap>(new PubSub());
+*
+* // Usage with Redis
+* const pubsub = new TypedPubSub<RedisPubSub, PubSubMap>(
+*   new RedisPubSub({
+*     publisher: new Redis(options),
+*     subscriber: new Redis(options),
+*   }),
+*   {
+*     prefix: "feature-1:",
+*   }
+* );
+* ```
+*/
+var TypedPubSub = class {
+	channelPrefix;
+	pubsub;
+	options;
+	constructor(pubsub, options) {
+		this.channelPrefix = options?.prefix ?? "";
+		this.pubsub = pubsub;
+		this.options = options;
+	}
+	publish = (channel, message, ...rest) => {
+		return this.pubsub.publish(this.mapChannel(channel), message, ...rest);
+	};
+	subscribe = (channel, onMessage, ...rest) => {
+		return this.pubsub.subscribe(this.mapChannel(channel), onMessage, ...rest);
+	};
+	unsubscribe = (subId, ...rest) => {
+		return this.pubsub.unsubscribe(subId, ...rest);
+	};
+	asyncIterableIterator = (triggers, ...rest) => {
+		return this.pubsub.asyncIterableIterator(this.mapTriggers(triggers), ...rest);
+	};
+	mapChannel = (channel) => {
+		return `${this.channelPrefix}${channel.toString()}`;
+	};
+	mapTriggers = (triggers) => {
+		return Array.isArray(triggers) ? triggers.map(this.mapChannel) : this.mapChannel(triggers);
+	};
+};
+
+//#endregion
+export { TypedPubSub };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"index.js","names":[],"sources":["../lib/typed-pubsub.ts"],"sourcesContent":["/** biome-ignore-all lint/suspicious/noExplicitAny: allow any args */\n\nimport type { PubSubEngine } from './pubsub-engine.ts';\n\n/**\n * Configuration options for TypedPubSub\n */\nexport interface TypedPubSubOptions {\n\t/** Optional prefix for channel names */\n\tprefix?: string;\n}\n\ntype PubSubMap = Record<string, any>;\ntype OnMessage<Payload> = (message: Payload) => Promise<void> | void;\n\ntype RestPayloadFnArgs<Fn> = Fn extends (\n\ttriggerName: string,\n\tpayload: any,\n\t...rest: infer Rest\n) => any\n\t? Rest\n\t: never;\n\ntype RestSubscribeFnArgs<Fn> = Fn extends (\n\ttriggerName: string,\n\tonMessage: OnMessage<any>,\n\t...rest: infer Rest\n) => any\n\t? Rest\n\t: never;\n\ntype RestUnsubscribeFnArgs<Fn> = Fn extends (subId: number, ...rest: infer Rest) => any\n\t? Rest\n\t: never;\n\ntype RestAsyncIterableIteratorFnArgs<Fn> = Fn extends (\n\ttriggers: string | readonly string[],\n\t...rest: infer Rest\n) => any\n\t? Rest\n\t: never;\n\n/**\n * Creates a type-safe wrapper around a PubSub implementation.\n *\n * This utility ensures that your subscription channels and their payloads\n * are properly typed, helping catch potential errors at compile time.\n *\n * @param pubsub - The PubSub engine instance (e.g., PubSub, RedisPubSub)\n * @param options - Configuration options\n *\n * @example\n * ```typescript\n * // Define your event map\n * type PubSubMap = {\n *   \"user-updated\": User;\n *   [c: `user-updated-${string}`]: User;\n * };\n *\n * // Create typed PubSub instance\n * const pubsub = new TypedPubSub<PubSub, PubSubMap>(new PubSub());\n *\n * // Usage with Redis\n * const pubsub = new TypedPubSub<RedisPubSub, PubSubMap>(\n *   new RedisPubSub({\n *     publisher: new Redis(options),\n *     subscriber: new Redis(options),\n *   }),\n *   {\n *     prefix: \"feature-1:\",\n *   }\n * );\n * ```\n */\nexport class TypedPubSub<Engine extends PubSubEngine, Map extends PubSubMap> {\n\tprotected channelPrefix: string;\n\tprotected pubsub: Engine;\n\tprotected options?: TypedPubSubOptions;\n\n\tconstructor(pubsub: Engine, options?: TypedPubSubOptions) {\n\t\tthis.channelPrefix = options?.prefix ?? '';\n\t\tthis.pubsub = pubsub;\n\t\tthis.options = options;\n\t}\n\n\tpublish = <C extends keyof Map>(\n\t\tchannel: C,\n\t\tmessage: Map[C],\n\t\t...rest: RestPayloadFnArgs<Engine['publish']>\n\t) => {\n\t\treturn this.pubsub.publish(this.mapChannel(channel), message, ...rest);\n\t};\n\n\tsubscribe = <C extends keyof Map>(\n\t\tchannel: C,\n\t\tonMessage: OnMessage<Map[C]>,\n\t\t...rest: RestSubscribeFnArgs<Engine['subscribe']>\n\t) => {\n\t\treturn this.pubsub.subscribe(this.mapChannel(channel), onMessage, ...rest);\n\t};\n\n\tunsubscribe = (subId: number, ...rest: RestUnsubscribeFnArgs<Engine['unsubscribe']>) => {\n\t\treturn this.pubsub.unsubscribe(subId, ...rest);\n\t};\n\n\tasyncIterableIterator = <C extends keyof Map>(\n\t\ttriggers: C | C[],\n\t\t...rest: RestAsyncIterableIteratorFnArgs<Engine['asyncIterableIterator']>\n\t) => {\n\t\treturn this.pubsub.asyncIterableIterator<Map[C]>(this.mapTriggers(triggers), ...rest);\n\t};\n\n\tprotected mapChannel = <C extends keyof Map>(channel: C): string => {\n\t\treturn `${this.channelPrefix}${channel.toString()}`;\n\t};\n\n\tprotected mapTriggers = <C extends keyof Map>(triggers: C | C[]): string | string[] => {\n\t\treturn Array.isArray(triggers) ? triggers.map(this.mapChannel) : this.mapChannel(triggers);\n\t};\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0EA,IAAa,cAAb,MAA6E;CAC5E,AAAU;CACV,AAAU;CACV,AAAU;CAEV,YAAY,QAAgB,SAA8B;AACzD,OAAK,gBAAgB,SAAS,UAAU;AACxC,OAAK,SAAS;AACd,OAAK,UAAU;;CAGhB,WACC,SACA,SACA,GAAG,SACC;AACJ,SAAO,KAAK,OAAO,QAAQ,KAAK,WAAW,QAAQ,EAAE,SAAS,GAAG,KAAK;;CAGvE,aACC,SACA,WACA,GAAG,SACC;AACJ,SAAO,KAAK,OAAO,UAAU,KAAK,WAAW,QAAQ,EAAE,WAAW,GAAG,KAAK;;CAG3E,eAAe,OAAe,GAAG,SAAuD;AACvF,SAAO,KAAK,OAAO,YAAY,OAAO,GAAG,KAAK;;CAG/C,yBACC,UACA,GAAG,SACC;AACJ,SAAO,KAAK,OAAO,sBAA8B,KAAK,YAAY,SAAS,EAAE,GAAG,KAAK;;CAGtF,AAAU,cAAmC,YAAuB;AACnE,SAAO,GAAG,KAAK,gBAAgB,QAAQ,UAAU;;CAGlD,AAAU,eAAoC,aAAyC;AACtF,SAAO,MAAM,QAAQ,SAAS,GAAG,SAAS,IAAI,KAAK,WAAW,GAAG,KAAK,WAAW,SAAS"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@baeta/subscriptions-pubsub",
-  "version": "2.0.0-next.2",
+  "version": "2.0.0-next.7",
   "keywords": [
     "baeta",
     "graphql",
@@ -37,17 +37,23 @@
     "package.json"
   ],
   "scripts": {
-    "build": "tsup",
-    "prepack": "prep",
-    "postpack": "prep --clean",
-    "test": "ava",
+    "build": "builder build",
+    "prepack": "builder prepare",
+    "postpack": "builder prepare --clean",
+    "test": "builder test",
+    "test:circular": "builder test-circular",
     "types": "tsc --noEmit"
   },
+  "ava": {
+    "extensions": {
+      "ts": "module"
+    }
+  },
   "devDependencies": {
     "@baeta/builder": "^0.0.0",
     "@baeta/testing": "^0.0.0",
     "@baeta/tsconfig": "^0.0.0",
-    "graphql": "^16.11.0",
+    "graphql": "^16.12.0",
     "graphql-subscriptions": "^3.0.0",
     "typescript": "^5.9.3"
   },
@@ -63,15 +69,6 @@
       }
     }
   },
-  "ava": {
-    "extensions": {
-      "ts": "module"
-    },
-    "nodeArguments": [
-      "--no-warnings",
-      "--experimental-transform-types"
-    ]
-  },
   "typedocOptions": {
     "entryPoints": [
       "./index.ts"