feat: add collection aliasing

Author: bevzzz

src/alias/index.ts

@@ -0,0 +1,31 @@
+import { ConnectionREST } from "../index.js";
+import { WeaviateAlias, WeaviateAliasResponse } from "../openapi/types.js";
+import { Alias, CreateAliasInput, UpdateAliasInput } from "./types.js";
+
+export interface Aliases {
+  create: (opt: CreateAliasInput) => Promise<void>;
+  listAll: (collection?: string) => Promise<Alias[] | undefined>
+  get: (alias: string) => Promise<Alias>;
+  update: (opt: UpdateAliasInput) => Promise<void>;
+  delete: (alias: string) => Promise<void>;
+}
+
+const alias = (connection: ConnectionREST): Aliases => {
+  return {
+    create: (opt: CreateAliasInput) => connection.postReturn<WeaviateAlias, void>(
+      `/aliases/`, { ...opt, class: opt.collection }),
+    listAll: (collection?: string) => connection.get<WeaviateAliasResponse>(
+      `/aliases${collection !== undefined ? "/?class=" + collection : ""}`)
+      .then(aliases => aliases.aliases !== undefined
+        ? aliases.aliases.map(alias => ({ alias: alias.alias, collection: alias.class }))
+        : []),
+    get: (alias: string) => connection.get<WeaviateAlias>(`/aliases/${alias}`)
+      .then(alias => ({ alias: alias.alias!, collection: alias.class! })),
+    update: (opt: UpdateAliasInput) => connection.put(
+      `/aliases/${opt.alias}`, { class: opt.newTargetCollection }),
+    delete: (alias: string) => connection.delete(
+      `/aliases/${alias}`, null),
+  }
+}
+
+export default alias;

src/alias/journey.test.ts

@@ -0,0 +1,53 @@
+import { assert } from 'console';
+import weaviate, {
+  WeaviateClient,
+} from '..';
+import { requireAtLeast } from '../../test/version';
+import { Alias } from './types';
+
+requireAtLeast(1, 32, 0).describe("manages collection aliases", () => {
+  let client: WeaviateClient;
+  const collectionsWithAliases = ["PaulHewson", "GeorgeBarnes", "ColsonBaker"];
+
+  beforeAll(async () => {
+    client = await weaviate.connectToLocal();
+    await Promise.all(collectionsWithAliases.map(client.collections.delete));
+    await Promise.all(collectionsWithAliases.map(name => client.collections.create({ name })));
+  });
+
+  it("should create alias", () => {
+    return Promise.all([
+      client.alias.create({ collection: "PaulHewson", alias: "Bono" }),
+      client.alias.create({ collection: "GeorgeBarnes", alias: "MachineGunKelly" }),
+    ])
+      .then(() => client.alias.listAll())
+      .then(aliases => {
+        expect(aliases).not.toBeUndefined();
+        expect(aliases).toHaveLength(2);
+        expect(aliases).toEqual<Alias[]>([
+          { collection: "PaulHewson", alias: "Bono" },
+          { collection: "GeorgeBarnes", alias: "MachineGunKelly" },
+        ]);
+      });
+  })
+
+  it("should update alias", () => {
+    return client.alias.update({ alias: "MachineGunKelly", newTargetCollection: "ColsonBaker" })
+      .then(() => client.alias.get("MachineGunKelly"))
+      .then(alias => {
+        expect(alias.collection).toEqual("ColsonBaker");
+      })
+  })
+
+  it("should delete alias Bono", () => {
+    return client.alias.delete("Bono")
+      .then(() => client.alias.listAll("PaulHewson"))
+      .then(aliases => expect(aliases).toEqual([]));
+  })
+
+  it("should delete alias MachineGunKelly", () => {
+    return client.alias.delete("MachineGunKelly")
+      .then(() => client.alias.listAll("ColsonBaker"))
+      .then(aliases => expect(aliases).toEqual([]));
+  })
+})

src/alias/types.ts

@@ -0,0 +1,14 @@
+export type Alias = {
+  collection: string;
+  alias: string;
+}
+
+export type CreateAliasInput = {
+  collection: string;
+  alias: string;
+};
+
+export type UpdateAliasInput = {
+  newTargetCollection: string;
+  alias: string;
+};

src/index.ts

@@ -41,6 +41,7 @@ import weaviateV2 from './v2/index.js';
 import filter from './collections/filters/index.js';
 import { ConsistencyLevel } from './data/replication.js';
 import users, { Users } from './users/index.js';
+import alias, { Aliases } from './alias/index.js';
 
 export type ProtocolParams = {
   /**
@@ -102,6 +103,7 @@ export type ClientParams = {
 };
 
 export interface WeaviateClient {
+  alias: Aliases;
   backup: Backup;
   cluster: Cluster;
   collections: Collections;
@@ -224,6 +226,7 @@ async function client(params: ClientParams): Promise<WeaviateClient> {
   });
 
   const ifc: WeaviateClient = {
+    alias: alias(connection),
     backup: backup(connection),
     cluster: cluster(connection),
     collections: collections(connection, dbVersionSupport),

src/openapi/types.ts

@@ -74,3 +74,8 @@ export type WeaviateUserType = definitions['UserTypeOutput'];
 export type WeaviateUserTypeInternal = definitions['UserTypeInput'];
 export type WeaviateUserTypeDB = definitions['DBUserInfo']['dbUserType'];
 export type WeaviateAssignedUser = operations['getUsersForRole']['responses']['200']['schema'][0];
+// Alias
+export type WeaviateAlias = definitions['Alias'];
+export type WeaviateAliasResponse = {
+  aliases?: Required<Exclude<definitions['AliasResponse']['aliases'], undefined>[0]>[] | undefined;
+};