@synnaxlabs/client 0.20.0 → 0.22.0

package/src/ontology/retriever.ts

@@ -1,91 +0,0 @@
-// Copyright 2023 Synnax Labs, Inc.
-//
-// Use of this software is governed by the Business Source License included in the file
-// licenses/BSL.txt.
-//
-// As of the Change Date specified in that file, in accordance with the Business Source
-// License, use of this software will be governed by the Apache License, Version 2.0,
-// included in the file licenses/APL.txt.
-
-import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
-import { toArray } from "@synnaxlabs/x";
-import { z } from "zod";
-
-import { ID, type Resource, idZ, resourceSchemaZ } from "@/ontology/payload";
-
-const reqZ = z.object({
-  ids: idZ.array().optional(),
-  children: z.boolean().optional(),
-  parents: z.boolean().optional(),
-  includeSchema: z.boolean().optional(),
-  includeFieldData: z.boolean().optional(),
-  term: z.string().optional(),
-});
-
-type Request = z.infer<typeof reqZ>;
-
-const resZ = z.object({
-  resources: resourceSchemaZ.array(),
-});
-
-export class Retriever {
-  private static readonly ENDPOINT = "/ontology/retrieve";
-  private readonly client: UnaryClient;
-
-  constructor(unary: UnaryClient) {
-    this.client = unary;
-  }
-
-  async search(term: string): Promise<Resource[]> {
-    const resources = await this.execute({ term });
-    return resources;
-  }
-
-  async retrieve(
-    ids: ID | ID[] | string | string[],
-    includeSchema: boolean = true,
-    includeFieldData: boolean = true,
-  ): Promise<Resource[]> {
-    return await this.execute({
-      ids: toArray(ids).map((id) => new ID(id).payload),
-      includeFieldData,
-      includeSchema,
-    });
-  }
-
-  async retrieveChildren(
-    ids: ID | ID[],
-    includeSchema: boolean = true,
-    includeFieldData: boolean = true,
-  ): Promise<Resource[]> {
-    return await this.execute({
-      ids: toArray(ids).map((id) => new ID(id).payload),
-      children: true,
-      includeSchema,
-      includeFieldData,
-    });
-  }
-
-  async retrieveParents(
-    ids: ID | ID[],
-    includeSchema: boolean = true,
-    includeFieldData: boolean = true,
-  ): Promise<Resource[]> {
-    return await this.execute({
-      ids: toArray(ids).map((id) => new ID(id).payload),
-      parents: true,
-      includeSchema,
-      includeFieldData,
-    });
-  }
-
-  private async execute(request: Request): Promise<Resource[]> {
-    return (await sendRequired(
-      this.client,
-      Retriever.ENDPOINT,
-      request,
-      reqZ,
-      resZ,
-    )).resources;
-  }
-}

package/src/ontology/signals.ts

@@ -1,139 +0,0 @@
-// Copyright 2023 Synnax Labs, Inc.
-//
-// Use of this software is governed by the Business Source License included in the file
-// licenses/BSL.txt.
-//
-// As of the Change Date specified in that file, in accordance with the Business Source
-// License, use of this software will be governed by the Apache License, Version 2.0,
-// included in the file licenses/APL.txt.
-
-import { observe, type change } from "@synnaxlabs/x";
-
-import { QueryError } from "@/errors";
-import { type Client as FrameClient } from "@/framer/client";
-import { type Frame } from "@/framer/frame";
-import { type Streamer as FrameStreamer } from "@/framer/streamer";
-import {
-  ID,
-  parseRelationship,
-  type Relationship,
-  type Resource,
-} from "@/ontology/payload";
-import { type Retriever } from "@/ontology/retriever";
-
-export type ResourceChange = change.Change<ID, Resource>;
-export type ResourceSet = change.Set<ID, Resource>;
-export type ResourceDelete = change.Delete<ID, Resource>;
-export type RelationshipChange = change.Change<Relationship, undefined>;
-export type RelationshipSet = change.Set<Relationship, undefined>;
-export type RelationshipDelete = change.Delete<Relationship, undefined>;
-
-const RESOURCE_SET_NAME = "sy_ontology_resource_set";
-const RESOURCE_DELETE_NAME = "sy_ontology_resource_delete";
-const RELATIONSHIP_SET_NAME = "sy_ontology_relationship_set";
-const RELATIONSHIP_DELETE_NAME = "sy_ontology_relationship_delete";
-
-export class ChangeTracker {
-  private readonly resourceObs: observe.Observer<ResourceChange[]>;
-  private readonly relationshipObs: observe.Observer<RelationshipChange[]>;
-
-  readonly relationships: observe.Observable<RelationshipChange[]>;
-  readonly resources: observe.Observable<ResourceChange[]>;
-
-  private readonly streamer: FrameStreamer;
-  private readonly retriever: Retriever;
-  private readonly closePromise: Promise<void>;
-
-  constructor(streamer: FrameStreamer, retriever: Retriever) {
-    this.relationshipObs = new observe.Observer<RelationshipChange[]>();
-    this.relationships = this.relationshipObs;
-    this.resourceObs = new observe.Observer<ResourceChange[]>();
-    this.resources = this.resourceObs;
-    this.retriever = retriever;
-    this.streamer = streamer;
-    this.closePromise = this.start();
-  }
-
-  async close(): Promise<void> {
-    this.streamer.close();
-    await this.closePromise;
-  }
-
-  private async start(): Promise<void> {
-    for await (const frame of this.streamer) {
-      await this.update(frame);
-    }
-  }
-
-  private async update(frame: Frame): Promise<void> {
-    const resSets = await this.parseResourceSets(frame);
-    const resDeletes = this.parseResourceDeletes(frame);
-    const allResources = resSets.concat(resDeletes);
-    if (allResources.length > 0) this.resourceObs.notify(resSets.concat(resDeletes));
-    const relSets = this.parseRelationshipSets(frame);
-    const relDeletes = this.parseRelationshipDeletes(frame);
-    const allRelationships = relSets.concat(relDeletes);
-    if (allRelationships.length > 0)
-      this.relationshipObs.notify(relSets.concat(relDeletes));
-  }
-
-  private parseRelationshipSets(frame: Frame): RelationshipChange[] {
-    const relationships = frame.get(RELATIONSHIP_SET_NAME);
-    if (relationships.length === 0) return [];
-    return Array.from(relationships.as("string")).map((rel) => ({
-      variant: "set",
-      key: parseRelationship(rel),
-      value: undefined,
-    }));
-  }
-
-  private parseRelationshipDeletes(frame: Frame): RelationshipChange[] {
-    const relationships = frame.get(RELATIONSHIP_DELETE_NAME);
-    if (relationships.length === 0) return [];
-    return Array.from(relationships.as("string")).map((rel) => ({
-      variant: "delete",
-      key: parseRelationship(rel),
-    }));
-  }
-
-  private async parseResourceSets(frame: Frame): Promise<ResourceChange[]> {
-    const sets = frame.get(RESOURCE_SET_NAME);
-    if (sets.length === 0) return [];
-    // We should only ever get one series of sets
-    const ids = Array.from(sets.as("string")).map((id: string) => new ID(id));
-    try {
-      const resources = await this.retriever.retrieve(ids);
-      return resources.map((resource) => ({
-        variant: "set",
-        key: resource.id,
-        value: resource,
-      }));
-    } catch (e) {
-      if (e instanceof QueryError) {
-        console.warn(e);
-        return [];
-      }
-      throw e;
-    }
-  }
-
-  private parseResourceDeletes(frame: Frame): ResourceChange[] {
-    const deletes = frame.get(RESOURCE_DELETE_NAME);
-    if (deletes.length === 0) return [];
-    // We should only ever get one series of deletes
-    return Array.from(deletes.as("string")).map((str) => ({
-      variant: "delete",
-      key: new ID(str),
-    }));
-  }
-
-  static async open(client: FrameClient, retriever: Retriever): Promise<ChangeTracker> {
-    const streamer = await client.openStreamer([
-      RESOURCE_SET_NAME,
-      RESOURCE_DELETE_NAME,
-      RELATIONSHIP_SET_NAME,
-      RELATIONSHIP_DELETE_NAME,
-    ]);
-    return new ChangeTracker(streamer, retriever);
-  }
-}

package/src/ranger/retriever.ts

@@ -1,50 +0,0 @@
-// Copyright 2023 Synnax Labs, Inc.
-//
-// Use of this software is governed by the Business Source License included in the file
-// licenses/BSL.txt.
-//
-// As of the Change Date specified in that file, in accordance with the Business Source
-// License, use of this software will be governed by the Apache License, Version 2.0,
-// included in the file licenses/APL.txt.
-
-import { type UnaryClient } from "@synnaxlabs/freighter";
-import { z } from "zod";
-
-import { type Params, type Payload, analyzeParams, keyZ, payloadZ } from "./payload";
-
-const reqZ = z.object({
-  keys: keyZ.array().optional(),
-  names: z.array(z.string()).optional(),
-  term: z.string().optional(),
-});
-
-type Request = z.infer<typeof reqZ>;
-
-const resZ = z.object({
-  ranges: z.array(payloadZ),
-});
-
-export class Retriever {
-  private readonly ENDPOINT = "/range/retrieve";
-  private readonly client: UnaryClient;
-
-  constructor(client: UnaryClient) {
-    this.client = client;
-  }
-
-  async retrieve(params: Params): Promise<Payload[]> {
-    const { normalized, variant } = analyzeParams(params);
-    const res = await this.execute({ [variant]: normalized });
-    return res;
-  }
-
-  async search(term: string): Promise<Payload[]> {
-    return await this.execute({ term });
-  }
-
-  private async execute(request: Request): Promise<Payload[]> {
-    const [res, err] = await this.client.send(this.ENDPOINT, request, reqZ, resZ);
-    if (err != null) throw err;
-    return res.ranges;
-  }
-}