more nats -> conat renaming

Author: williamstein

src/packages/backend/conat/test/service.test.ts

@@ -6,7 +6,7 @@ pnpm test ./service.test.ts
 
 */
 
-import { callNatsService, createNatsService } from "@cocalc/conat/service";
+import { callConatService, createConatService } from "@cocalc/conat/service";
 import { once } from "@cocalc/util/async-utils";
 import { before, after } from "@cocalc/backend/conat/test/setup";
 import { wait } from "@cocalc/backend/conat/test/util";
@@ -16,22 +16,20 @@ beforeAll(before);
 describe("create a service and test it out", () => {
   let s;
   it("creates a service", async () => {
-    s = createNatsService({
+    s = createConatService({
       service: "echo",
       handler: (mesg) => mesg.repeat(2),
     });
     await once(s, "running");
-    expect(await callNatsService({ service: "echo", mesg: "hello" })).toBe(
+    expect(await callConatService({ service: "echo", mesg: "hello" })).toBe(
       "hellohello",
     );
   });
 
   it("closes the services and observes it doesn't work anymore", async () => {
     s.close();
-
-    let t = "";
     await expect(async () => {
-      await callNatsService({ service: "echo", mesg: "hi", timeout: 1000 });
+      await callConatService({ service: "echo", mesg: "hi", timeout: 1000 });
     }).rejects.toThrowError("timeout");
   });
 });
@@ -40,12 +38,12 @@ describe("verify that you can create a service AFTER calling it and things to st
   let result = "";
   it("call a service that does not exist yet", () => {
     (async () => {
-      result = await callNatsService({ service: "echo3", mesg: "hello " });
+      result = await callConatService({ service: "echo3", mesg: "hello " });
     })();
   });
 
   it("create the echo3 service and observe that it answer the request we made before the service was created", async () => {
-    const s = createNatsService({
+    const s = createConatService({
       service: "echo3",
       handler: (mesg) => mesg.repeat(3),
     });

src/packages/conat/service/index.ts

@@ -1,8 +1,8 @@
 export type {
   ServiceDescription,
-  CallNatsServiceFunction,
+  CallConatServiceFunction,
   ServiceCall,
-  CreateNatsServiceFunction,
-  NatsService,
+  CreateConatServiceFunction,
+  ConatService,
 } from "./service";
-export { callNatsService, createNatsService } from "./service";
+export { callConatService, createConatService } from "./service";

src/packages/conat/service/service.ts

@@ -1,8 +1,8 @@
 /*
 Simple to use UI to connect anything in cocalc via request/reply services.
 
-- callNatsService
-- createNatsService
+- callConatService
+- createConatService
 
 The input is basically where the service is (account, project, public),
 and either what message to send or how to handle messages.
@@ -46,8 +46,8 @@ export interface ServiceCall extends ServiceDescription {
   noRetry?: boolean;
 }
 
-export async function callNatsService(opts: ServiceCall): Promise<any> {
-  // console.log("callNatsService", opts);
+export async function callConatService(opts: ServiceCall): Promise<any> {
+  // console.log("callConatService", opts);
   const env = await getEnv();
   const { cn } = env;
   const subject = serviceSubject(opts);
@@ -79,7 +79,7 @@ export async function callNatsService(opts: ServiceCall): Promise<any> {
       if (err.code == 503) {
         // it's actually just not ready, so
         // wait for the service to be ready, then try again
-        await waitForNatsService({ options: opts, maxWait: timeout });
+        await waitForConatService({ options: opts, maxWait: timeout });
         try {
           return await doRequest();
         } catch (err) {
@@ -98,19 +98,19 @@ export async function callNatsService(opts: ServiceCall): Promise<any> {
   }
 }
 
-export type CallNatsServiceFunction = typeof callNatsService;
+export type CallConatServiceFunction = typeof callConatService;
 
 export interface Options extends ServiceDescription {
   description?: string;
   version?: string;
   handler: (mesg) => Promise<any>;
 }
 
-export function createNatsService(options: Options) {
-  return new NatsService(options);
+export function createConatService(options: Options) {
+  return new ConatService(options);
 }
 
-export type CreateNatsServiceFunction = typeof createNatsService;
+export type CreateConatServiceFunction = typeof createConatService;
 
 export function serviceSubject({
   service,
@@ -180,7 +180,7 @@ export function serviceDescription({
   return [description, path ? `\nPath: ${path}` : ""].join("");
 }
 
-export class NatsService extends EventEmitter {
+export class ConatService extends EventEmitter {
   private options: Options;
   private subject: string;
   private sub?;
@@ -264,11 +264,11 @@ interface ServiceClientOpts {
   id?: string;
 }
 
-export async function pingNatsService({
+export async function pingConatService({
   options,
   maxWait = 3000,
 }: ServiceClientOpts): Promise<string[]> {
-  const pong = await callNatsService({
+  const pong = await callConatService({
     ...options,
     mesg: "ping",
     timeout: Math.max(3000, maxWait),
@@ -278,7 +278,7 @@ export async function pingNatsService({
   return [pong];
 }
 
-export async function waitForNatsService({
+export async function waitForConatService({
   options,
   maxWait = 60000,
 }: {
@@ -290,7 +290,7 @@ export async function waitForNatsService({
   const start = Date.now();
   const getPing = async (m: number) => {
     try {
-      return await pingNatsService({ options, maxWait: m });
+      return await pingConatService({ options, maxWait: m });
     } catch {
       // ping can fail, e.g, if not connected to nats at all or the ping
       // service isn't up yet.

src/packages/conat/service/typed.ts

@@ -1,13 +1,13 @@
 import {
-  callNatsService,
-  createNatsService,
-  pingNatsService,
-  waitForNatsService,
+  callConatService,
+  createConatService,
+  pingConatService,
+  waitForConatService,
 } from "./service";
 import type { Options, ServiceCall } from "./service";
 
 export interface Extra {
-  ping: typeof pingNatsService;
+  ping: typeof pingConatService;
   waitFor: (opts?: { maxWait?: number }) => Promise<void>;
 }
 
@@ -26,14 +26,14 @@ export function createServiceClient<Api>(options: Omit<ServiceCall, "mesg">) {
         if (prop == "nats") {
           return {
             ping: async (opts: { id?: string; maxWait?: number } = {}) =>
-              await pingNatsService({ options, ...opts }),
+              await pingConatService({ options, ...opts }),
             waitFor: async (opts: { maxWait?: number } = {}) =>
-              await waitForNatsService({ options, ...opts }),
+              await waitForConatService({ options, ...opts }),
           };
         }
         return async (...args) => {
           try {
-            return await callNatsService({
+            return await callConatService({
               ...options,
               mesg: { name: prop, args },
             });
@@ -51,7 +51,7 @@ export async function createServiceHandler<Api>({
   impl,
   ...options
 }: Omit<Options, "handler"> & { impl: Api }) {
-  return await createNatsService({
+  return await createConatService({
     ...options,
     handler: async (mesg) => await impl[mesg.name](...mesg.args),
   });

src/packages/frontend/client/client.ts

@@ -34,8 +34,8 @@ import { ACCOUNT_ID_COOKIE_NAME } from "@cocalc/util/db-schema/accounts";
 import { appBasePath } from "@cocalc/frontend/customize/app-base-path";
 import type { NatsSyncTableFunction } from "@cocalc/conat/sync/synctable";
 import type {
-  CallNatsServiceFunction,
-  CreateNatsServiceFunction,
+  CallConatServiceFunction,
+  CreateConatServiceFunction,
 } from "@cocalc/conat/service";
 import type { NatsEnvFunction } from "@cocalc/conat/types";
 import { randomId } from "@cocalc/conat/names";
@@ -92,8 +92,8 @@ export interface WebappClient extends EventEmitter {
   is_signed_in: () => boolean;
   synctable_project: Function;
   synctable_nats: NatsSyncTableFunction;
-  callNatsService: CallNatsServiceFunction;
-  createNatsService: CreateNatsServiceFunction;
+  callConatService: CallConatServiceFunction;
+  createConatService: CreateConatServiceFunction;
   getNatsEnv: NatsEnvFunction;
   pubsub_nats: Function;
   prettier: Function;
@@ -176,8 +176,8 @@ class Client extends EventEmitter implements WebappClient {
   is_signed_in: () => boolean;
   synctable_project: Function;
   synctable_nats: NatsSyncTableFunction;
-  callNatsService: CallNatsServiceFunction;
-  createNatsService: CreateNatsServiceFunction;
+  callConatService: CallConatServiceFunction;
+  createConatService: CreateConatServiceFunction;
   getNatsEnv: NatsEnvFunction;
   pubsub_nats: Function;
   prettier: Function;
@@ -271,8 +271,8 @@ class Client extends EventEmitter implements WebappClient {
     );
     this.synctable_nats = this.nats_client.synctable;
     this.pubsub_nats = this.nats_client.pubsub;
-    this.callNatsService = this.nats_client.callNatsService;
-    this.createNatsService = this.nats_client.createNatsService;
+    this.callConatService = this.nats_client.callConatService;
+    this.createConatService = this.nats_client.createConatService;
     this.getNatsEnv = this.nats_client.getEnv;
 
     this.query = this.query_client.query.bind(this.query_client);

src/packages/frontend/conat/client.ts

@@ -31,10 +31,10 @@ import {
 } from "@cocalc/conat/sync/stream";
 import { dstream } from "@cocalc/conat/sync/dstream";
 import { delay } from "awaiting";
-import { callNatsService, createNatsService } from "@cocalc/conat/service";
+import { callConatService, createConatService } from "@cocalc/conat/service";
 import type {
-  CallNatsServiceFunction,
-  CreateNatsServiceFunction,
+  CallConatServiceFunction,
+  CreateConatServiceFunction,
 } from "@cocalc/conat/service";
 import { listingsClient } from "@cocalc/conat/service/listings";
 import {
@@ -216,12 +216,12 @@ export class NatsClient extends EventEmitter {
     }
   };
 
-  callNatsService: CallNatsServiceFunction = async (options) => {
-    return await callNatsService(options);
+  callConatService: CallConatServiceFunction = async (options) => {
+    return await callConatService(options);
   };
 
-  createNatsService: CreateNatsServiceFunction = (options) => {
-    return createNatsService(options);
+  createConatService: CreateConatServiceFunction = (options) => {
+    return createConatService(options);
   };
 
   // TODO: plan to deprecated...?

src/packages/jupyter/kernel/nats-service.ts

@@ -13,7 +13,7 @@ import { createNatsJupyterService } from "@cocalc/conat/service/jupyter";
 import { get_existing_kernel as getKernel } from "@cocalc/jupyter/kernel";
 import { bufferToBase64 } from "@cocalc/util/base64";
 
-export async function initNatsService({
+export async function initConatService({
   path,
   project_id,
 }: {

src/packages/jupyter/redux/project-actions.ts

@@ -30,7 +30,7 @@ import nbconvertChange from "./handle-nbconvert-change";
 import type { ClientFs } from "@cocalc/sync/client/types";
 import { kernel as createJupyterKernel } from "@cocalc/jupyter/kernel";
 import { removeJupyterRedux } from "@cocalc/jupyter/kernel";
-import { initNatsService } from "@cocalc/jupyter/kernel/nats-service";
+import { initConatService } from "@cocalc/jupyter/kernel/nats-service";
 import { type DKV, dkv } from "@cocalc/conat/sync/dkv";
 import { computeServerManager } from "@cocalc/conat/compute/manager";
 import { reuseInFlight } from "@cocalc/util/reuse-in-flight";
@@ -223,7 +223,7 @@ export class JupyterActions extends JupyterActions0 {
       this.natsService.close();
       this.natsService = null;
     }
-    const service = (this.natsService = await initNatsService({
+    const service = (this.natsService = await initConatService({
       project_id: this.project_id,
       path: this.path,
     }));

src/packages/project/client.ts

@@ -53,10 +53,10 @@ import pubsub from "@cocalc/project/conat/pubsub";
 import type { NatsSyncTableFunction } from "@cocalc/conat/sync/synctable";
 import { getEnv as getNatsEnv } from "@cocalc/project/conat/env";
 import {
-  callNatsService,
-  createNatsService,
-  type CallNatsServiceFunction,
-  type CreateNatsServiceFunction,
+  callConatService,
+  createConatService,
+  type CallConatServiceFunction,
+  type CreateConatServiceFunction,
 } from "@cocalc/conat/service";
 import type { NatsEnvFunction } from "@cocalc/conat/types";
 
@@ -528,12 +528,12 @@ export class Client extends EventEmitter implements ProjectClientInterface {
     return await pubsub({ path, name });
   };
 
-  callNatsService: CallNatsServiceFunction = async (options) => {
-    return await callNatsService(options);
+  callConatService: CallConatServiceFunction = async (options) => {
+    return await callConatService(options);
   };
 
-  createNatsService: CreateNatsServiceFunction = (options) => {
-    return createNatsService({
+  createConatService: CreateConatServiceFunction = (options) => {
+    return createConatService({
       ...options,
       project_id: this.project_id,
     });

src/packages/project/conat/listings.ts

@@ -43,13 +43,13 @@ import { compute_server_id, project_id } from "@cocalc/project/data";
 import { init as initClient } from "@cocalc/project/client";
 import { delay } from "awaiting";
 import { type DKV } from "./sync";
-import { type NatsService } from "@cocalc/conat/service";
+import { type ConatService } from "@cocalc/conat/service";
 import { MultipathWatcher } from "@cocalc/backend/path-watcher";
 import getLogger from "@cocalc/backend/logger";
 
 const logger = getLogger("project:nats:listings");
 
-let service: NatsService | null;
+let service: ConatService | null;
 export async function init() {
   logger.debug("init: initializing");
   initClient();