gomtm 0.0.2 → 0.0.4

package/dist/esm/clientlib.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+export declare function mergeRefs<T = any>(refs: Array<React.MutableRefObject<T> | React.LegacyRef<T>>): React.RefCallback<T>;
+export declare function getCookie(name: string): string | undefined;
+export declare function deleteCookie(name: string): void;
+export declare function deleteAllCookies(): void;
+export declare function setCookie(name: string, value: any): void;

package/dist/esm/clientlib.js

@@ -0,0 +1,44 @@
+"use client";
+function mergeRefs(refs) {
+  return (value) => {
+    refs.forEach((ref) => {
+      if (typeof ref === "function") {
+        ref(value);
+      } else if (ref != null) {
+        ;
+        ref.current = value;
+      }
+    });
+  };
+}
+function getCookie(name) {
+  const cookieArr = document.cookie.split(";");
+  for (let i = 0; i < cookieArr.length; i++) {
+    const cookiePair = cookieArr[i].split("=");
+    if (name == cookiePair[0].trim()) {
+      return decodeURIComponent(cookiePair[1]);
+    }
+  }
+}
+function deleteCookie(name) {
+  document.cookie = name + "=;expires=Thu, 01 Jan 1970 00:00:00 GMT";
+}
+function deleteAllCookies() {
+  const cookies = document.cookie.split(";");
+  for (let i = 0; i < cookies.length; i++) {
+    const cookie = cookies[i];
+    const eqPos = cookie.indexOf("=");
+    const name = eqPos > -1 ? cookie.substr(0, eqPos) : cookie;
+    document.cookie = name + "=;expires=Thu, 01 Jan 1970 00:00:00 GMT";
+  }
+}
+function setCookie(name, value) {
+  document.cookie = `${name}=${value}`;
+}
+export {
+  deleteAllCookies,
+  deleteCookie,
+  getCookie,
+  mergeRefs,
+  setCookie
+};

package/dist/esm/consts.d.ts

@@ -0,0 +1,28 @@
+export declare const COOKIE_MTM_SITE_ID = "mtm-site-id";
+export declare const COOKIE_IS_DEBUG = "DEBUG";
+export declare const MTM_SITE_HOSTNAME = "mtm-site-hostname";
+export declare const MtM_TOKEN_NAME = "mtm_token33";
+export declare const fetchMaxRetry = 3;
+export declare const HeaderMtmHost = "Mtm-Host";
+export declare const HeaderMtmApi = "Mtm-Api";
+export declare const Cookie_Site_Host = "site-host";
+export declare const MTM_SERVER_COOKIE_ACTIVATE_URL = "mtm:serverUrl";
+export declare const MTM_SERVER_COOKIE_ACTIVATE_SELFBACKEND_URL = "mtm:selfbackendUrl";
+export declare const DEFAULT_revalidate_SECONDS = 3;
+export declare const LOGIN_CALLBACK_URL_KEY = "back";
+export declare const ExtKey_Hostname = "host";
+export declare const ExtKey_mtmaccessToken = "access_token";
+export declare const ExtKey_mtmbackend = "mtmbackend";
+export declare const ExtKey_SelfBackend = "selfbackend";
+export declare const ItemAction_list_new_item = "list_new_item";
+export declare const Listview_list_filter = "Listview_list_filter";
+export declare const ActionEdit = "edit";
+export declare const ActionDelete = "delete";
+export declare const ActionCreate = "create";
+export declare const ActionFetchNextPage = "fetchNextPage";
+export declare const ActionRefetch = "refetch";
+export declare const ListView_DefaultPageSize = 12;
+export declare const ImageNoExist = "/images/404.jpg";
+export declare const ADMIN_ROLE = "admin";
+export declare const MEMBER_ROLE = "member";
+export declare const TRPC_API_PREFIX = "/api.v1/trpc";

package/dist/esm/consts.js

@@ -0,0 +1,58 @@
+const COOKIE_MTM_SITE_ID = "mtm-site-id";
+const COOKIE_IS_DEBUG = "DEBUG";
+const MTM_SITE_HOSTNAME = "mtm-site-hostname";
+const MtM_TOKEN_NAME = "mtm_token33";
+const fetchMaxRetry = 3;
+const HeaderMtmHost = "Mtm-Host";
+const HeaderMtmApi = "Mtm-Api";
+const Cookie_Site_Host = "site-host";
+const MTM_SERVER_COOKIE_ACTIVATE_URL = "mtm:serverUrl";
+const MTM_SERVER_COOKIE_ACTIVATE_SELFBACKEND_URL = "mtm:selfbackendUrl";
+const DEFAULT_revalidate_SECONDS = 3;
+const LOGIN_CALLBACK_URL_KEY = "back";
+const ExtKey_Hostname = "host";
+const ExtKey_mtmaccessToken = "access_token";
+const ExtKey_mtmbackend = "mtmbackend";
+const ExtKey_SelfBackend = "selfbackend";
+const ItemAction_list_new_item = "list_new_item";
+const Listview_list_filter = "Listview_list_filter";
+const ActionEdit = "edit";
+const ActionDelete = "delete";
+const ActionCreate = "create";
+const ActionFetchNextPage = "fetchNextPage";
+const ActionRefetch = "refetch";
+const ListView_DefaultPageSize = 12;
+const ImageNoExist = "/images/404.jpg";
+const ADMIN_ROLE = "admin";
+const MEMBER_ROLE = "member";
+const TRPC_API_PREFIX = "/api.v1/trpc";
+export {
+  ADMIN_ROLE,
+  ActionCreate,
+  ActionDelete,
+  ActionEdit,
+  ActionFetchNextPage,
+  ActionRefetch,
+  COOKIE_IS_DEBUG,
+  COOKIE_MTM_SITE_ID,
+  Cookie_Site_Host,
+  DEFAULT_revalidate_SECONDS,
+  ExtKey_Hostname,
+  ExtKey_SelfBackend,
+  ExtKey_mtmaccessToken,
+  ExtKey_mtmbackend,
+  HeaderMtmApi,
+  HeaderMtmHost,
+  ImageNoExist,
+  ItemAction_list_new_item,
+  LOGIN_CALLBACK_URL_KEY,
+  ListView_DefaultPageSize,
+  Listview_list_filter,
+  MEMBER_ROLE,
+  MTM_SERVER_COOKIE_ACTIVATE_SELFBACKEND_URL,
+  MTM_SERVER_COOKIE_ACTIVATE_URL,
+  MTM_SITE_HOSTNAME,
+  MtM_TOKEN_NAME,
+  TRPC_API_PREFIX,
+  fetchMaxRetry
+};

package/dist/esm/http/cors.d.ts

@@ -0,0 +1,15 @@
+type StaticOrigin = boolean | string | RegExp | (boolean | string | RegExp)[];
+type OriginFn = (origin: string | undefined, req: Request) => StaticOrigin | Promise<StaticOrigin>;
+interface CorsOptions {
+    origin?: StaticOrigin | OriginFn;
+    methods?: string | string[];
+    allowedHeaders?: string | string[];
+    exposedHeaders?: string | string[];
+    credentials?: boolean;
+    maxAge?: number;
+    preflightContinue?: boolean;
+    optionsSuccessStatus?: number;
+}
+export default function cors(req: Request, res: Response, options?: CorsOptions): Promise<Response>;
+export declare function initCors(options?: CorsOptions): (req: Request, res: Response) => Promise<Response>;
+export {};

package/dist/esm/http/cors.js

@@ -0,0 +1,129 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+const defaultOptions = {
+  origin: "*",
+  methods: "GET,HEAD,PUT,PATCH,POST,DELETE",
+  preflightContinue: false,
+  optionsSuccessStatus: 204
+};
+function isOriginAllowed(origin, allowed) {
+  return Array.isArray(allowed) ? allowed.some((o) => isOriginAllowed(origin, o)) : typeof allowed === "string" ? origin === allowed : allowed instanceof RegExp ? allowed.test(origin) : !!allowed;
+}
+function getOriginHeaders(reqOrigin, origin) {
+  const headers = new Headers();
+  if (origin === "*") {
+    headers.set("Access-Control-Allow-Origin", "*");
+  } else if (typeof origin === "string") {
+    headers.set("Access-Control-Allow-Origin", origin);
+    headers.append("Vary", "Origin");
+  } else {
+    const allowed = isOriginAllowed(reqOrigin != null ? reqOrigin : "", origin);
+    if (allowed && reqOrigin) {
+      headers.set("Access-Control-Allow-Origin", reqOrigin);
+    }
+    headers.append("Vary", "Origin");
+  }
+  return headers;
+}
+function originHeadersFromReq(req, origin) {
+  return __async(this, null, function* () {
+    const reqOrigin = req.headers.get("Origin") || void 0;
+    const value = typeof origin === "function" ? yield origin(reqOrigin, req) : origin;
+    if (!value)
+      return;
+    return getOriginHeaders(reqOrigin, value);
+  });
+}
+function getAllowedHeaders(req, allowed) {
+  const headers = new Headers();
+  if (!allowed) {
+    allowed = req.headers.get("Access-Control-Request-Headers");
+    headers.append("Vary", "Access-Control-Request-Headers");
+  } else if (Array.isArray(allowed)) {
+    allowed = allowed.join(",");
+  }
+  if (allowed) {
+    headers.set("Access-Control-Allow-Headers", allowed);
+  }
+  return headers;
+}
+function cors(req, res, options) {
+  return __async(this, null, function* () {
+    var _a;
+    const opts = __spreadValues(__spreadValues({}, defaultOptions), options);
+    const { headers } = res;
+    const originHeaders = yield originHeadersFromReq(req, (_a = opts.origin) != null ? _a : false);
+    const mergeHeaders = (v, k) => {
+      if (k === "Vary")
+        headers.append(k, v);
+      else
+        headers.set(k, v);
+    };
+    if (!originHeaders)
+      return res;
+    originHeaders.forEach(mergeHeaders);
+    if (opts.credentials) {
+      headers.set("Access-Control-Allow-Credentials", "true");
+    }
+    const exposed = Array.isArray(opts.exposedHeaders) ? opts.exposedHeaders.join(",") : opts.exposedHeaders;
+    if (exposed) {
+      headers.set("Access-Control-Expose-Headers", exposed);
+    }
+    if (req.method === "OPTIONS") {
+      if (opts.methods) {
+        const methods = Array.isArray(opts.methods) ? opts.methods.join(",") : opts.methods;
+        headers.set("Access-Control-Allow-Methods", methods);
+      }
+      getAllowedHeaders(req, opts.allowedHeaders).forEach(mergeHeaders);
+      if (typeof opts.maxAge === "number") {
+        headers.set("Access-Control-Max-Age", String(opts.maxAge));
+      }
+      if (opts.preflightContinue)
+        return res;
+      headers.set("Content-Length", "0");
+      return new Response(null, { status: opts.optionsSuccessStatus, headers });
+    }
+    return res;
+  });
+}
+function initCors(options) {
+  return (req, res) => cors(req, res, options);
+}
+export {
+  cors as default,
+  initCors
+};

package/dist/esm/http/fetchMiddleWithCache.d.ts

@@ -0,0 +1,2 @@
+import type { FetchType } from "./mthttp";
+export declare function fetchMiddleWithCache(fetcher: FetchType): (input: string | URL | globalThis.Request, init?: RequestInit) => Promise<Response>;

package/dist/esm/http/fetchMiddleWithCache.js

@@ -0,0 +1,87 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { LRUCache } from "lru-cache";
+import { sha256WithAlphabets } from "../utils";
+const options = {
+  max: 500,
+  // for use with tracking overall storage size
+  maxSize: 5e3,
+  sizeCalculation: (value, key) => {
+    return 1;
+  },
+  // for use when you need to clean up something when objects
+  // are evicted from the cache
+  // dispose: (value, key) => {
+  //   // freeFromMemoryOrWhatever(value)
+  // },
+  ttl: 1e3 * 30,
+  // return stale items before removing from cache?
+  allowStale: false,
+  updateAgeOnGet: false,
+  updateAgeOnHas: false
+};
+const cache = new LRUCache(options);
+const makeCacheKey = (input, init) => {
+  const req = new Request(input, init);
+  const token = req.headers.get("authorization");
+  let body = "";
+  if (init == null ? void 0 : init.body) {
+    body = init.body.toString();
+  }
+  return sha256WithAlphabets(input + token + body);
+};
+function fetchMiddleWithCache(fetcher) {
+  return (input, init) => __async(this, null, function* () {
+    const key = yield makeCacheKey(input, init);
+    const cacheObj = cache.get(key);
+    if (cacheObj) {
+      return new Response(new Uint8Array(cacheObj));
+    } else {
+      const response = yield fetcher(input, init);
+      if (response.status == 200 && response.body) {
+        const [s1, s2] = response.body.tee();
+        writeStreamToCache(key, s2);
+        return new Response(s1, response);
+      }
+      return response.clone();
+    }
+  });
+}
+function writeStreamToCache(key, steam) {
+  return __async(this, null, function* () {
+    const chunks = [];
+    let done = false;
+    const s2Reader = yield steam.getReader();
+    while (!done) {
+      const { value, done: readerDone } = yield s2Reader.read();
+      done = readerDone;
+      if (value)
+        chunks.push(value);
+    }
+    const byteArray = new Uint8Array(chunks.reduce((acc, chunk) => [...acc, ...Array.from(chunk)], []));
+    if (byteArray.buffer.byteLength > 0) {
+      cache.set(key, byteArray.buffer);
+    }
+  });
+}
+export {
+  fetchMiddleWithCache
+};

package/dist/esm/http/fetchMiddleWithUrlProxy.d.ts

@@ -0,0 +1,2 @@
+import type { FetchType } from "./mthttp";
+export declare function fetchMiddleWithUrlProxy(fetcher: FetchType): (input: string | URL | globalThis.Request, init?: RequestInit) => Promise<Response>;

package/dist/esm/http/fetchMiddleWithUrlProxy.js

@@ -0,0 +1,28 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+function fetchMiddleWithUrlProxy(fetcher) {
+  return (input, init) => __async(this, null, function* () {
+    return fetcher(input, init);
+  });
+}
+export {
+  fetchMiddleWithUrlProxy
+};

package/dist/esm/http/mthttp.d.ts

@@ -0,0 +1,5 @@
+export type FetchType = typeof fetch;
+export declare const responseJson: (data: any) => Response;
+export declare function jsonResponse(data: any): Promise<Response>;
+export declare function jsonSuccessResponse(data?: any): Promise<Response>;
+export declare function getContentType(req: Request): string | null;

package/dist/esm/http/mthttp.js

@@ -0,0 +1,61 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+const responseJson = (data) => {
+  return new Response(JSON.stringify(data), {
+    status: 200,
+    headers: {
+      "Content-type": "application/json"
+    }
+  });
+};
+function jsonResponse(data) {
+  return __async(this, null, function* () {
+    try {
+      return new Response(JSON.stringify(data), {
+        status: 200,
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    } catch (e) {
+      console.log(e);
+      return new Response(JSON.stringify({ error: e.message }));
+    }
+  });
+}
+function jsonSuccessResponse(data) {
+  return __async(this, null, function* () {
+    return jsonResponse({
+      success: true,
+      data
+    });
+  });
+}
+function getContentType(req) {
+  const a = req.headers.get("Content-Type");
+  return a;
+}
+export {
+  getContentType,
+  jsonResponse,
+  jsonSuccessResponse,
+  responseJson
+};

package/dist/esm/http/response-cache.test.js

@@ -0,0 +1,72 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { fetchMiddleWithCache } from "./fetchMiddleWithCache";
+test("fetch \u7F13\u5B58\u6B63\u5E38\u60C5\u51B5", () => __async(void 0, null, function* () {
+  const fetchFn = jest.fn(fetch);
+  const fetchWithCache = fetchMiddleWithCache(fetchFn);
+  const count = 10;
+  for (let i = 0; i < count; i++) {
+    fetchFn.mockReturnValueOnce(Promise.resolve(new Response("abc", {})));
+    const res = yield fetchWithCache("https://www.bing.com", {
+      headers: {
+        authorization: "token2"
+      }
+    });
+    const content = yield res.text();
+    expect(content).toContain("abc");
+  }
+  expect(fetchFn.mock.calls.length).toBe(1);
+}));
+test("fetch \u975E200\u54CD\u5E94\u4E0D\u505A\u7F13\u5B58", () => __async(void 0, null, function* () {
+  const fetchFn = jest.fn(fetch);
+  const fetchWithCache = fetchMiddleWithCache(fetchFn);
+  const count = 10;
+  for (let i = 0; i < count; i++) {
+    fetchFn.mockReturnValueOnce(Promise.resolve(
+      new Response("some content", {
+        status: 500
+      })
+    ));
+    const res = yield fetchWithCache("https://www.bing.com", {
+      headers: {
+        authorization: "token1"
+      }
+    });
+    const content = yield res.text();
+    expect(content).toContain("some conten");
+  }
+  expect(fetchFn.mock.calls.length).toBe(count);
+}));
+test("fetch \u7F13\u5B58\u4E0D\u540C\u7684url", () => __async(void 0, null, function* () {
+  const fetchFn = jest.fn(fetch);
+  const count = 10;
+  const fetchWithCache = fetchMiddleWithCache(fetchFn);
+  for (let i = 0; i < count; i++) {
+    fetchFn.mockReturnValueOnce(Promise.resolve(new Response("abc", {})));
+    const res = yield fetchWithCache(`https://www.bing.com/${i}`, {
+      headers: {
+        authorization: "token2"
+      }
+    });
+    expect(yield res.text()).toContain("abc");
+  }
+  expect(fetchFn.mock.calls.length).toBe(10);
+}));

package/dist/esm/messageTypeRegistry.d.ts

@@ -0,0 +1,4 @@
+import { IMessageTypeRegistry, ServiceType } from "@bufbuild/protobuf";
+export declare const anypbTypeReg: IMessageTypeRegistry;
+export declare const allServices: Record<string, ServiceType>;
+export declare const GetMtmServiceByTypeName: (serviceTypeName: string) => ServiceType;

package/dist/esm/messageTypeRegistry.js

@@ -0,0 +1,36 @@
+import { createRegistry } from "@bufbuild/protobuf";
+import { BotService } from "./gomtmpb/mtm/sppb/bot_connect";
+import { CmdStartNoVnc, CmdStartSimpleCrawler, ConsumMessageReq, CxPageReq, HelloBotMessage } from "./gomtmpb/mtm/sppb/bot_pb";
+import { CxService } from "./gomtmpb/mtm/sppb/cx_connect";
+import { JobService } from "./gomtmpb/mtm/sppb/job_connect";
+import { MtmService } from "./gomtmpb/mtm/sppb/mtm_connect";
+import { SpService } from "./gomtmpb/mtm/sppb/sp_connect";
+const anypbTypeReg = createRegistry(
+  HelloBotMessage,
+  CxPageReq,
+  ConsumMessageReq,
+  CmdStartNoVnc,
+  CmdStartSimpleCrawler
+);
+const allServices = {};
+const registerService = (...s) => {
+  s.map((item) => {
+    const servieTypeName = item.typeName;
+    allServices[servieTypeName] = item;
+  });
+};
+const GetMtmServiceByTypeName = (serviceTypeName) => {
+  return allServices[serviceTypeName];
+};
+registerService(
+  MtmService,
+  SpService,
+  BotService,
+  JobService,
+  CxService
+);
+export {
+  GetMtmServiceByTypeName,
+  allServices,
+  anypbTypeReg
+};

package/dist/esm/mtmFetcher.d.ts

@@ -0,0 +1,13 @@
+import { Message, PartialMessage, ServiceType } from "@bufbuild/protobuf";
+import { MtUnaryCallError } from "./connectquery/utils";
+import { ExtInfo } from "./mtmcore";
+type CustomRequestInit = RequestInit & {
+    enableCache?: boolean;
+    enableLog?: boolean;
+};
+export declare const newMtmFetch: (extInfo: ExtInfo, initGlobal?: CustomRequestInit) => (input: string | URL | globalThis.Request, init?: CustomRequestInit) => Promise<Response>;
+export declare function getMtmApiUrl(backendUrl: string): string;
+export declare function createMtConnectTransport(backendUrl: string, extInfo: ExtInfo): import("@connectrpc/connect").Transport;
+export declare function createClient<T extends ServiceType>(extInfo: ExtInfo, svc: T, options: CustomRequestInit): import("@connectrpc/connect").PromiseClient<T>;
+export declare function mtmCallUnaryMethod<I extends Message<I>, O extends Message<O>>(extInfo: ExtInfo, svc: string, method: string, input?: PartialMessage<I> | undefined): Promise<O | MtUnaryCallError>;
+export {};