@akanjs/signal 0.0.53 → 0.0.55

package/index.mjs

@@ -0,0 +1 @@
+export * from "./src";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/signal",
-  "version": "0.0.53",
+  "version": "0.0.55",
   "type": "commonjs",
   "publishConfig": {
     "access": "public"
@@ -20,5 +20,11 @@
     "next": "^15.3.2",
     "reflect-metadata": "^0.2.2",
     "socket.io-client": "^4.8.1"
+  },
+  "exports": {
+    ".": {
+      "require": "./index.js",
+      "import": "./index.mjs"
+    }
   }
 }

package/src/baseFetch.mjs

@@ -0,0 +1,15 @@
+import { client } from "./client";
+const nativeFetch = fetch;
+const baseFetch = Object.assign(nativeFetch, {
+  client,
+  clone: function(option = {}) {
+    return {
+      ...this,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+      client: this.client.clone(option)
+    };
+  }
+});
+export {
+  baseFetch
+};

package/src/client.mjs

@@ -0,0 +1,145 @@
+import { baseClientEnv, baseEnv } from "@akanjs/base";
+import { Logger, sleep } from "@akanjs/common";
+import { cacheExchange, createClient, fetchExchange } from "@urql/core";
+import { io } from "socket.io-client";
+class SocketIo {
+  socket;
+  roomSubscribeMap = /* @__PURE__ */ new Map();
+  constructor(uri) {
+    this.socket = io(uri, { transports: ["websocket"] });
+    this.socket.on("connect", () => {
+      this.roomSubscribeMap.forEach((option) => {
+        this.socket.emit(option.key, { ...option.message, __subscribe__: true });
+      });
+    });
+  }
+  on(event, callback) {
+    this.socket.on(event, callback);
+  }
+  removeListener(event, callback) {
+    this.socket.removeListener(event, callback);
+  }
+  removeAllListeners() {
+    this.socket.removeAllListeners();
+  }
+  hasListeners(event) {
+    return this.socket.hasListeners(event);
+  }
+  emit(key, data) {
+    this.socket.emit(key, data);
+  }
+  subscribe(option) {
+    if (!this.roomSubscribeMap.has(option.roomId)) {
+      this.roomSubscribeMap.set(option.roomId, option);
+      this.socket.emit(option.key, { ...option.message, __subscribe__: true });
+    }
+    this.socket.on(option.roomId, option.handleEvent);
+  }
+  unsubscribe(roomId, handleEvent) {
+    this.socket.removeListener(roomId, handleEvent);
+    const option = this.roomSubscribeMap.get(roomId);
+    if (this.hasListeners(roomId) || !option)
+      return;
+    this.roomSubscribeMap.delete(roomId);
+    this.socket.emit(option.key, { ...option.message, __subscribe__: false });
+  }
+  disconnect() {
+    this.socket.disconnect();
+    return this;
+  }
+}
+class Client {
+  static globalIoMap = /* @__PURE__ */ new Map();
+  static tokenStore = /* @__PURE__ */ new Map();
+  async waitUntilWebSocketConnected(ws = baseClientEnv.serverWsUri) {
+    if (baseClientEnv.side === "server")
+      return true;
+    while (!this.getIo(ws).socket.connected) {
+      Logger.verbose("waiting for websocket to initialize...");
+      await sleep(300);
+    }
+  }
+  isInitialized = false;
+  uri = baseClientEnv.serverGraphqlUri;
+  ws = baseClientEnv.serverWsUri;
+  udp = null;
+  gql = createClient({ url: this.uri, fetch, exchanges: [cacheExchange, fetchExchange] });
+  jwt = null;
+  async getJwt() {
+    const isNextServer = baseClientEnv.side === "server" && baseEnv.operationType === "client";
+    if (isNextServer) {
+      const nextHeaders = require("next/headers");
+      return (await nextHeaders.cookies?.())?.get("jwt")?.value ?? (await nextHeaders.headers?.())?.get("jwt") ?? this.jwt ?? null;
+    } else
+      return Client.tokenStore.get(this) ?? null;
+  }
+  io = null;
+  init(data = {}) {
+    Object.assign(this, data);
+    this.setLink(data.uri);
+    this.setIo(data.ws);
+    this.isInitialized = true;
+  }
+  setIo(ws = baseClientEnv.serverWsUri) {
+    this.ws = ws;
+    const existingIo = Client.globalIoMap.get(ws);
+    if (existingIo) {
+      this.io = existingIo;
+      return;
+    }
+    this.io = new SocketIo(ws);
+    Client.globalIoMap.set(ws, this.io);
+  }
+  getIo(ws = baseClientEnv.serverWsUri) {
+    const existingIo = Client.globalIoMap.get(ws);
+    if (existingIo)
+      return existingIo;
+    const io2 = new SocketIo(ws);
+    Client.globalIoMap.set(ws, io2);
+    return io2;
+  }
+  setLink(uri = baseClientEnv.serverGraphqlUri) {
+    this.uri = uri;
+    this.gql = createClient({
+      url: this.uri,
+      fetch,
+      exchanges: [cacheExchange, fetchExchange],
+      // requestPolicy: "network-only",
+      fetchOptions: () => {
+        return {
+          headers: {
+            "apollo-require-preflight": "true",
+            ...this.jwt ? { authorization: `Bearer ${this.jwt}` } : {}
+          }
+        };
+      }
+    });
+  }
+  setJwt(jwt) {
+    Client.tokenStore.set(this, jwt);
+  }
+  reset() {
+    this.io?.disconnect();
+    this.io = null;
+    this.jwt = null;
+  }
+  clone(data = {}) {
+    const newClient = new Client();
+    newClient.init({ ...this, ...data });
+    if (data.jwt)
+      Client.tokenStore.set(newClient, data.jwt);
+    return newClient;
+  }
+  terminate() {
+    this.reset();
+    Client.globalIoMap.forEach((io2) => io2.disconnect());
+    this.isInitialized = false;
+  }
+  setUdp(udp) {
+    this.udp = udp;
+  }
+}
+const client = new Client();
+export {
+  client
+};

package/src/doc.mjs

@@ -0,0 +1,82 @@
+import { arraiedModel, getNonArrayModel, isGqlScalar, JSON as GqlJSON } from "@akanjs/base";
+import { getFieldMetas, getScalarExample } from "@akanjs/constant";
+import { getArgMetas, getGqlMeta } from "./signalDecorators";
+class ResponseExampleStorage {
+}
+const getPredefinedRequestExample = (modelRef) => {
+  return Reflect.getMetadata(modelRef, ResponseExampleStorage.prototype);
+};
+const getPredefinedResponseExample = (modelRef) => {
+  return Reflect.getMetadata(modelRef, ResponseExampleStorage.prototype);
+};
+const getResponseExample = (ref) => {
+  const [modelRef, arrDepth] = getNonArrayModel(ref);
+  const existing = getPredefinedRequestExample(modelRef);
+  if (existing)
+    return existing;
+  const isScalar = isGqlScalar(modelRef);
+  if (isScalar)
+    return arraiedModel(getScalarExample(modelRef), arrDepth);
+  const fieldMetas = getFieldMetas(modelRef);
+  const example = {};
+  fieldMetas.forEach((fieldMeta) => {
+    if (fieldMeta.example)
+      example[fieldMeta.key] = fieldMeta.example;
+    else if (fieldMeta.enum)
+      example[fieldMeta.key] = arraiedModel(fieldMeta.enum.values[0], fieldMeta.arrDepth);
+    else
+      example[fieldMeta.key] = getResponseExample(fieldMeta.modelRef);
+  });
+  const result = arraiedModel(example, arrDepth);
+  Reflect.defineMetadata(ref, result, ResponseExampleStorage.prototype);
+  return result;
+};
+class RequestExampleStorage {
+}
+const getRequestExample = (ref) => {
+  const existing = getPredefinedRequestExample(ref);
+  if (existing)
+    return existing;
+  const fieldMetas = getFieldMetas(ref);
+  const example = {};
+  const isScalar = isGqlScalar(ref);
+  if (isScalar)
+    return getScalarExample(ref);
+  else {
+    fieldMetas.forEach((fieldMeta) => {
+      if (!fieldMeta.isScalar && fieldMeta.isClass)
+        example[fieldMeta.key] = "ObjectID";
+      else
+        example[fieldMeta.key] = fieldMeta.example ?? fieldMeta.enum ? arraiedModel(fieldMeta.example ?? (fieldMeta.enum?.values)[0], fieldMeta.optArrDepth) : arraiedModel(getRequestExample(fieldMeta.modelRef), fieldMeta.arrDepth);
+    });
+  }
+  Reflect.defineMetadata(ref, example, RequestExampleStorage.prototype);
+  return example;
+};
+const makeRequestExample = (sigRef, key) => {
+  const [argMetas] = getArgMetas(sigRef, key);
+  return getExampleData(argMetas);
+};
+const getExampleData = (argMetas, signalType = "graphql") => Object.fromEntries(
+  argMetas.filter((argMeta) => argMeta.type !== "Upload").map((argMeta) => {
+    const [argRef, argArrDepth] = getNonArrayModel(argMeta.returns());
+    const example = argMeta.argsOption.example ?? getRequestExample(argRef);
+    return [
+      argMeta.name,
+      arraiedModel(
+        signalType === "restapi" && argRef.prototype === GqlJSON.prototype ? JSON.stringify(example, null, 2) : example,
+        argArrDepth
+      )
+    ];
+  })
+);
+const makeResponseExample = (sigRef, key) => {
+  const gqlMeta = getGqlMeta(sigRef, key);
+  const example = getResponseExample(gqlMeta.returns());
+  return example;
+};
+export {
+  getExampleData,
+  makeRequestExample,
+  makeResponseExample
+};