@covenant-rpc/core 0.3.0 → 0.4.0

package/procedure.ts

@@ -1,105 +0,0 @@
-import type { StandardSchemaV1 } from "@standard-schema/spec";
-import type { ProcedureDeclaration, ProcedureType } from ".";
-import type { MaybePromise } from "./utils";
-import { v } from "./validation";
-import type { Logger } from "./logger";
-
-export interface ProcedureRequest {
-  headers: Headers;
-  input: unknown;
-  url: string;
-  procedure: string;
-  path: string;
-  req: Request;
-}
-
-export interface ProcedureInputs<Inputs, Context, Derivation> {
-  inputs: Inputs,
-  ctx: Context,
-  derived: Derivation,
-  request: ProcedureRequest,
-  logger: Logger,
-  setHeader: (name: string, value: string) => void;
-  deleteHeader: (name: string) => void;
-  error: (message: string, code: number) => never;
-}
-
-export interface ResourceInputs<Inputs, Context, Outputs> {
-  inputs: Inputs,
-  logger: Logger,
-  ctx: Context,
-  outputs: Outputs,
-}
-
-export type ProcedureDefinition<T, Context, Derivation> = T extends ProcedureDeclaration<
-  infer InputSchema,
-  infer OutputSchema,
-  ProcedureType> ? {
-    procedure: (i: ProcedureInputs<
-      StandardSchemaV1.InferOutput<InputSchema>,
-      Context,
-      Derivation
-    >) => MaybePromise<StandardSchemaV1.InferOutput<OutputSchema>>
-    resources: (i: ResourceInputs<
-      StandardSchemaV1.InferOutput<InputSchema>,
-      Context,
-      StandardSchemaV1.InferOutput<OutputSchema>
-    >) => MaybePromise<string[]>
-  } : never
-
-
-export const procedureErrorSchema = v.obj({
-  message: v.string(),
-  code: v.number(),
-});
-
-export type ProcedureError = v.Infer<typeof procedureErrorSchema>;
-
-
-export const procedureResponseSchema = v.union(
-  v.obj({
-    status: v.literal("OK"),
-    data: v.unknown(),
-    resources: v.array(v.string()),
-  }),
-  v.obj({
-    status: v.literal("ERR"),
-    error: procedureErrorSchema,
-  }),
-);
-
-export type ProcedureResponse = v.Infer<typeof procedureResponseSchema>;
-
-export const procedureRequestBodySchema = v.obj({
-  procedure: v.string(),
-  inputs: v.unknown(),
-});
-
-export type ProcedureRequestBody = v.Infer<typeof procedureRequestBodySchema>;
-
-
-export type InferProcedureInputs<P> = P extends ProcedureDeclaration<
-  infer InputSchema,
-  any,
-  any
-> ? StandardSchemaV1.InferInput<InputSchema> : never;
-
-
-export type InferProcedureOutputs<P> = P extends ProcedureDeclaration<
-  any,
-  infer OutputSchema,
-  any
-> ? StandardSchemaV1.InferOutput<OutputSchema> : never
-
-
-export type InferProcedureResult<P> = {
-  success: true,
-  data: InferProcedureOutputs<P>,
-  resources: string[]
-  error: null,
-} | {
-  success: false,
-  error: ProcedureError,
-  data: null,
-  resources: null,
-}

package/sidekick/protocol.ts

@@ -1,104 +0,0 @@
-import { channelErrorSchema } from "../channel";
-import { v } from "../validation";
-
-
-
-// tokens are given to the server and the sidekick at the same time
-export const subscribeMessageSchema = v.obj({
-  type: v.literal("subscribe"),
-  token: v.string(),
-});
-export type SubscribeMessage = v.Infer<typeof subscribeMessageSchema>;
-
-export const unsubscribeMessageSchema = v.obj({
-  type: v.literal("unsubscribe"),
-  token: v.string(),
-});
-export type UnsubscribeMessage = v.Infer<typeof unsubscribeMessageSchema>;
-
-export const sendMessageSchema = v.obj({
-  type: v.literal("send"),
-  token: v.string(),
-  channel: v.string(),
-  params: v.record(v.string(), v.string()),
-  data: v.unknown(),
-});
-export type SendMessage = v.Infer<typeof sendMessageSchema>;
-
-export const listenMessageSchema = v.obj({
-  type: v.literal("listen"),
-  resources: v.array(v.string()),
-});
-export type ListenMessage = v.Infer<typeof listenMessageSchema>;
-
-export const unlistenMessageSchema = v.obj({
-  type: v.literal("unlisten"),
-  resources: v.array(v.string()),
-});
-export type UnlistenMessage = v.Infer<typeof unlistenMessageSchema>;
-
-export const sidekickIncomingMessageSchema = v.union(
-  subscribeMessageSchema,
-  unsubscribeMessageSchema,
-  sendMessageSchema,
-  listenMessageSchema,
-  unlistenMessageSchema,
-);
-export type SidekickIncomingMessage = v.Infer<typeof sidekickIncomingMessageSchema>;
-
-
-export const sidekickOutgoingMessageSchema = v.union(
-  v.obj({
-    type: v.literal("error"),
-    error: channelErrorSchema,
-  }),
-  v.obj({
-    type: v.literal("message"),
-    channel: v.string(),
-    params: v.record(v.string(), v.string()),
-    data: v.unknown(),
-  }),
-  v.obj({
-    type: v.literal("updated"),
-    resource: v.string(),
-  }),
-  v.obj({
-    type: v.literal("listening"),
-    resources: v.array(v.string()),
-  }),
-  v.obj({
-    type: v.literal("unlistening"),
-    resources: v.array(v.string()),
-  }),
-  v.obj({
-    type: v.literal("subscribed"),
-    channel: v.string(),
-    params: v.record(v.string(), v.string()),
-  }),
-  v.obj({
-    type: v.literal("unsubscribed"),
-    channel: v.string(),
-    params: v.record(v.string(), v.string()),
-  }),
-  v.obj({
-    type: v.literal("listening"),
-    channel: v.string(),
-    params: v.record(v.string(), v.string()),
-  }),
-)
-
-export type SidekickOutgoingMessage = v.Infer<typeof sidekickOutgoingMessageSchema>;
-
-
-export function getChannelTopicName(channel: string, params: Record<string, string>) {
-  const map = Object.keys(params).map(k => `${k}:${params[k]}`).join(",");
-  return `channel:${channel}/${map}`
-}
-
-export function getResourceTopicName(resource: string) {
-  return `resource:${resource}`;
-}
-
-export function getMapId(wsId: string, topic: string) {
-  return `${wsId}@${topic}`;
-}

package/utils.ts

@@ -1,87 +0,0 @@
-import type { StandardSchemaV1 } from "@standard-schema/spec";
-
-export type MaybePromise<T> = T | Promise<T>;
-export type Flatten<T> = { [k in keyof T]: T[k] } & {};
-export type ArrayToMap<T extends readonly string[]> = { [k in T[number]]: string };
-
-
-
-export type Result<T> = {
-  success: true;
-  data: T;
-  error: null;
-} | {
-  success: false;
-  data: null;
-  error: Error
-}
-
-export type AsyncResult<T> = Promise<Result<T>>;
-
-
-export function ok<T>(t: T): Result<T> {
-  return {
-    data: t,
-    success: true,
-    error: null,
-  }
-}
-
-export function err(error: Error): Result<any> {
-  return {
-    data: null,
-    success: false,
-    error,
-  }
-}
-
-export function issuesToString(issues: readonly StandardSchemaV1.Issue[]): string {
-  const strs: string[] = []
-
-  for (const issue of issues) {
-    strs.push(`${issue.path}: ${issue.message}`);
-  }
-
-
-  return strs.join(", ");
-}
-
-
-
-export type PubsubListener<T> = (t: T) => MaybePromise<void>;
-
-export class MultiTopicPubsub<T> {
-  private listenerMap: Map<string, PubsubListener<T>[]> = new Map();
-
-  subscribe(topic: string, listener: PubsubListener<T>) {
-    if (this.listenerMap.has(topic)) {
-      const newListeners = [...this.listenerMap.get(topic)!, listener];
-      this.listenerMap.set(topic, newListeners);
-    } else {
-      this.listenerMap.set(topic, [listener]);
-    }
-  }
-
-  unsubscribe(topic: string, listener: PubsubListener<T>) {
-    if (this.listenerMap.has(topic)) {
-      const listeners = this.listenerMap.get(topic)!;
-      this.listenerMap.set(topic, listeners.filter(l => l !== listener));
-    }
-  }
-
-  async publish(topic: string, data: T) {
-    const listeners = this.listenerMap.get(topic) ?? [];
-
-    const promises = listeners.map(l => l(data));
-    await Promise.all(promises);
-  }
-}
-
-
-
-export function isPromise(obj: unknown): obj is Promise<unknown> {
-  return obj != null &&
-    typeof obj === "object" &&
-    typeof (obj as any).then === "function";
-}
-

package/validation.ts

@@ -1,99 +0,0 @@
-// Covenant cannot have any dependencies, so I have to make a very tiny validation library for parsing requests. This does not implement standard schema, and should not be used
-// outside of covenant code. If you are doing so, you are wrong
-export namespace v {
-  export type Validator<T> = (o: unknown) => o is T;
-  export type Infer<K> = K extends Validator<infer T> ? T : never;
-
-  export const bool: () => Validator<boolean> = () => (o: unknown) => typeof o === "boolean";
-  export const number: () => Validator<number> = () => (o: unknown) => typeof o === "number"
-  export const string: () => Validator<string> = () => (o: unknown) => typeof o === "string";
-  export const unknown: () => Validator<unknown> = () => (o: unknown): o is unknown => true;
-
-  export function optional<T>(validator: Validator<T>): Validator<T | undefined> {
-    return (o: unknown) => validator(o) || o === undefined;
-  }
-  export function nullable<T>(validator: Validator<T>): Validator<T | null> {
-    return (o: unknown) => validator(o) || o === null;
-  }
-
-  export function union<T extends readonly Validator<any>[]>(...validators: T): Validator<Infer<T[number]>> {
-    return (o: unknown): o is Infer<T[number]> => {
-      return validators.some(validator => validator(o));
-    };
-  }
-
-  export function literal<T extends string | number | boolean | null | undefined>(value: T): Validator<T> {
-    return (o: unknown): o is T => o === value;
-  }
-
-  export function obj<T extends Record<string, Validator<any>>>(obj: T): Validator<{ [K in keyof T]: Infer<T[K]> }> {
-    return (o: unknown): o is { [K in keyof T]: Infer<T[K]> } => {
-      if (typeof o !== "object" || o === null || o === undefined) {
-        return false;
-      }
-      
-      const target = o as Record<string, unknown>;
-
-      for (const key of Object.keys(obj)) {
-        const validator = obj[key]!;
-        const valid = validator(target[key]);
-        if (!valid) {
-          return false;
-        }
-      }
-
-      return true;
-    }
-  }
-
-  export function parse<T>(object: unknown, validator: Validator<T>): T {
-    const valid = validator(object);
-
-    if (!valid) {
-      throw new Error("Validation failed!");
-    }
-
-    return object;
-  }
-
-  export function parseSafe<T>(object: unknown, validator: Validator<T>): T | null {
-    const valid = validator(object);
-
-    if (!valid) {
-      return null;
-    }
-
-    return object;
-  }
-
-  export function array<T>(elementValidator: Validator<T>): Validator<T[]> {
-    return (o: unknown): o is T[] => {
-      if (!Array.isArray(o)) {
-        return false;
-      }
-      return o.every(element => elementValidator(element));
-    };
-  }
-
-  export function record<K extends string | number | symbol, V>(
-    keyValidator: Validator<K>,
-    valueValidator: Validator<V>
-  ): Validator<Record<K, V>> {
-    return (o: unknown): o is Record<K, V> => {
-      if (typeof o !== "object" || o === null || o === undefined) {
-        return false;
-      }
-      
-      const target = o as Record<string | number | symbol, unknown>;
-      
-      for (const [key, value] of Object.entries(target)) {
-        if (!keyValidator(key) || !valueValidator(value)) {
-          return false;
-        }
-      }
-      
-      return true;
-    };
-  }
-}
-