@voidhash/mimic-sdk 1.0.0-beta.18

package/src/effect/CollectionHandle.ts

@@ -0,0 +1,120 @@
+import { Effect } from "effect";
+import type { Primitive } from "@voidhash/mimic";
+import { RpcClient } from "effect/unstable/rpc";
+import { MimicRpcs } from "@voidhash/mimic-protocol";
+import type { DocumentSnapshot, CreatedDocumentToken } from "./types";
+
+const makeClient = () => RpcClient.make(MimicRpcs);
+
+export class CollectionHandle<TSchema extends Primitive.AnyPrimitive> {
+  readonly id: string;
+  readonly databaseId: string;
+  readonly schema: TSchema;
+
+  constructor(id: string, databaseId: string, schema: TSchema) {
+    this.id = id;
+    this.databaseId = databaseId;
+    this.schema = schema;
+  }
+
+  create(data: Primitive.InferSetInput<TSchema>, options?: { id?: string }) {
+    const collectionId = this.id;
+    return Effect.scoped(
+      Effect.gen(function* () {
+        const client = yield* makeClient();
+        const result = yield* client.CreateDocument({
+          collectionId,
+          id: options?.id,
+          data,
+        });
+        return result as unknown as DocumentSnapshot<Primitive.InferState<TSchema>>;
+      }),
+    );
+  }
+
+  get(documentId: string) {
+    const collectionId = this.id;
+    return Effect.scoped(
+      Effect.gen(function* () {
+        const client = yield* makeClient();
+        const result = yield* client.GetDocument({
+          collectionId,
+          documentId,
+        });
+        return result as unknown as DocumentSnapshot<Primitive.InferState<TSchema>>;
+      }),
+    );
+  }
+
+  update(documentId: string, data: Primitive.InferUpdateInput<TSchema>) {
+    const collectionId = this.id;
+    return Effect.scoped(
+      Effect.gen(function* () {
+        const client = yield* makeClient();
+        const result = yield* client.UpdateDocument({
+          collectionId,
+          documentId,
+          data,
+        });
+        return { id: result.id, version: result.version };
+      }),
+    );
+  }
+
+  set(documentId: string, data: Primitive.InferSetInput<TSchema>) {
+    const collectionId = this.id;
+    return Effect.scoped(
+      Effect.gen(function* () {
+        const client = yield* makeClient();
+        const result = yield* client.SetDocument({
+          collectionId,
+          documentId,
+          data,
+        });
+        return { id: result.id, version: result.version };
+      }),
+    );
+  }
+
+  delete(documentId: string) {
+    const collectionId = this.id;
+    return Effect.scoped(
+      Effect.gen(function* () {
+        const client = yield* makeClient();
+        yield* client.DeleteDocument({
+          collectionId,
+          documentId,
+        });
+      }),
+    );
+  }
+
+  list() {
+    const collectionId = this.id;
+    return Effect.scoped(
+      Effect.gen(function* () {
+        const client = yield* makeClient();
+        const result = yield* client.ListDocuments({
+          collectionId,
+        });
+        return result as unknown as DocumentSnapshot<Primitive.InferState<TSchema>>[];
+      }),
+    );
+  }
+
+  createDocumentToken(documentId: string, permission: "read" | "write", expiresInSeconds?: number) {
+    const collectionId = this.id;
+    return Effect.scoped(
+      Effect.gen(function* () {
+        const client = yield* makeClient();
+        const result = yield* client.CreateDocumentToken({
+          collectionId,
+          documentId,
+          permission,
+          expiresInSeconds,
+        });
+        return { token: result.token } as CreatedDocumentToken;
+      }),
+    );
+  }
+}

package/src/effect/DatabaseHandle.ts

@@ -0,0 +1,76 @@
+import { Effect } from "effect";
+import { type Primitive, SchemaJSON } from "@voidhash/mimic";
+import { RpcClient } from "effect/unstable/rpc";
+import { MimicRpcs } from "@voidhash/mimic-protocol";
+import { CollectionHandle } from "./CollectionHandle";
+import type { CollectionInfo } from "./types";
+
+const makeClient = () => RpcClient.make(MimicRpcs);
+
+export class DatabaseHandle {
+  readonly id: string;
+  readonly name: string;
+  readonly description: string;
+
+  constructor(id: string, name: string, description: string) {
+    this.id = id;
+    this.name = name;
+    this.description = description;
+  }
+
+  createCollection<TSchema extends Primitive.AnyPrimitive>(name: string, schema: TSchema) {
+    const databaseId = this.id;
+    return Effect.scoped(
+      Effect.gen(function* () {
+        const client = yield* makeClient();
+        const schemaJson = SchemaJSON.toJSON(schema);
+        const result = yield* client.CreateCollection({
+          databaseId,
+          name,
+          schemaJson,
+        });
+        return new CollectionHandle<TSchema>(result.id, result.databaseId, schema);
+      }),
+    );
+  }
+
+  listCollections() {
+    const databaseId = this.id;
+    return Effect.scoped(
+      Effect.gen(function* () {
+        const client = yield* makeClient();
+        const result = yield* client.ListCollections({ databaseId });
+        return result as unknown as CollectionInfo[];
+      }),
+    );
+  }
+
+  deleteCollection(id: string) {
+    return Effect.scoped(
+      Effect.gen(function* () {
+        const client = yield* makeClient();
+        yield* client.DeleteCollection({ id });
+      }),
+    );
+  }
+
+  collection<TSchema extends Primitive.AnyPrimitive>(
+    id: string,
+    schema: TSchema,
+  ): CollectionHandle<TSchema> {
+    return new CollectionHandle<TSchema>(id, this.id, schema);
+  }
+
+  updateCollectionSchema(collectionId: string, schemaJson: unknown) {
+    return Effect.scoped(
+      Effect.gen(function* () {
+        const client = yield* makeClient();
+        const result = yield* client.UpdateCollectionSchema({
+          id: collectionId,
+          schemaJson,
+        });
+        return { id: result.id, schemaVersion: result.schemaVersion };
+      }),
+    );
+  }
+}

package/src/effect/HttpTransport.ts

@@ -0,0 +1,43 @@
+import { Layer } from "effect";
+import { RpcClient, RpcSerialization, RpcMiddleware } from "effect/unstable/rpc";
+import { FetchHttpClient } from "effect/unstable/http";
+import { AuthMiddleware } from "@voidhash/mimic-protocol";
+
+export interface MimicClientConfig {
+  readonly url: string;
+  readonly username: string;
+  readonly password: string;
+  readonly timeout?: number;
+}
+
+export const MimicClientLayer = (config: MimicClientConfig) => {
+  const baseUrl = config.url.replace(/\/+$/, "");
+  const basicAuth = btoa(`${config.username}:${config.password}`);
+
+  const ProtocolLive = RpcClient.layerProtocolHttp({
+    url: `${baseUrl}/rpc`,
+  });
+
+  const SerializationLive = RpcSerialization.layerNdjson;
+
+  const AuthLive = RpcMiddleware.layerClient(
+    AuthMiddleware,
+    ({ next, request }) =>
+      next({
+        ...request,
+        headers: {
+          ...request.headers,
+          authorization: `Basic ${basicAuth}`,
+        },
+      }),
+  );
+
+  return Layer.mergeAll(
+    ProtocolLive.pipe(
+      Layer.provide(FetchHttpClient.layer),
+      Layer.provide(SerializationLive),
+    ),
+    SerializationLive,
+    AuthLive,
+  );
+};

package/src/effect/MimicSDK.ts

@@ -0,0 +1,118 @@
+import { Effect } from "effect";
+import { RpcClient, RpcSerialization, RpcClientError, RpcMiddleware } from "effect/unstable/rpc";
+import { MimicRpcs, type AuthMiddleware } from "@voidhash/mimic-protocol";
+import { DatabaseHandle } from "./DatabaseHandle";
+import type { DatabaseInfo, UserInfo, GrantInfo } from "./types";
+
+export type MimicRpcRequirements =
+  | RpcClient.Protocol
+  | RpcSerialization.RpcSerialization
+  | RpcMiddleware.ForClient<AuthMiddleware>;
+
+const makeClient = () => RpcClient.make(MimicRpcs);
+
+export const createDatabase = (options: {
+  name: string;
+  description?: string;
+}) =>
+  Effect.scoped(
+    Effect.gen(function* () {
+      const client = yield* makeClient();
+      const result = yield* client.CreateDatabase({
+        name: options.name,
+        description: options.description ?? "",
+      });
+      return new DatabaseHandle(result.id, result.name, result.description);
+    }),
+  );
+
+export const listDatabases = () =>
+  Effect.scoped(
+    Effect.gen(function* () {
+      const client = yield* makeClient();
+      const result = yield* client.ListDatabases(undefined as any);
+      return result as unknown as DatabaseInfo[];
+    }),
+  );
+
+export const deleteDatabase = (id: string) =>
+  Effect.scoped(
+    Effect.gen(function* () {
+      const client = yield* makeClient();
+      yield* client.DeleteDatabase({ id });
+    }),
+  );
+
+export const database = (id: string, name = "", description = ""): DatabaseHandle =>
+  new DatabaseHandle(id, name, description);
+
+export const createUser = (options: {
+  username: string;
+  password: string;
+}) =>
+  Effect.scoped(
+    Effect.gen(function* () {
+      const client = yield* makeClient();
+      const result = yield* client.CreateUser({
+        username: options.username,
+        password: options.password,
+      });
+      return { id: result.id, username: result.username };
+    }),
+  );
+
+export const listUsers = () =>
+  Effect.scoped(
+    Effect.gen(function* () {
+      const client = yield* makeClient();
+      const result = yield* client.ListUsers(undefined as any);
+      return result as unknown as UserInfo[];
+    }),
+  );
+
+export const deleteUser = (id: string) =>
+  Effect.scoped(
+    Effect.gen(function* () {
+      const client = yield* makeClient();
+      yield* client.DeleteUser({ id });
+    }),
+  );
+
+export const grantPermission = (options: {
+  userId: string;
+  databaseId: string;
+  permission: "read" | "write" | "admin";
+}) =>
+  Effect.scoped(
+    Effect.gen(function* () {
+      const client = yield* makeClient();
+      yield* client.GrantPermission({
+        userId: options.userId,
+        databaseId: options.databaseId,
+        permission: options.permission,
+      });
+    }),
+  );
+
+export const revokePermission = (options: {
+  userId: string;
+  databaseId: string;
+}) =>
+  Effect.scoped(
+    Effect.gen(function* () {
+      const client = yield* makeClient();
+      yield* client.RevokePermission({
+        userId: options.userId,
+        databaseId: options.databaseId,
+      });
+    }),
+  );
+
+export const listGrants = (userId?: string) =>
+  Effect.scoped(
+    Effect.gen(function* () {
+      const client = yield* makeClient();
+      const result = yield* client.ListGrants({ userId });
+      return result as unknown as GrantInfo[];
+    }),
+  );

package/src/effect/errors.ts

@@ -0,0 +1,7 @@
+import { Data } from "effect";
+
+export class MimicSDKError extends Data.TaggedError("MimicSDKError")<{
+  readonly message: string;
+  readonly method?: string;
+  readonly cause?: unknown;
+}> {}

package/src/effect/index.ts

@@ -0,0 +1,15 @@
+export { MimicClientLayer, type MimicClientConfig } from "./HttpTransport";
+export { MimicSDKError } from "./errors";
+export type {
+  DatabaseInfo,
+  CollectionInfo,
+  UserInfo,
+  GrantInfo,
+  CreatedDocumentToken,
+  DocumentSnapshot,
+} from "./types";
+export { DatabaseHandle } from "./DatabaseHandle";
+export { CollectionHandle } from "./CollectionHandle";
+export * as MimicSDK from "./MimicSDK";
+export type { MimicRpcRequirements } from "./MimicSDK";
+export { MimicRpcs, CurrentUser, AuthMiddleware } from "@voidhash/mimic-protocol";

package/src/effect/types.ts

@@ -0,0 +1,35 @@
+export interface DatabaseInfo {
+  readonly id: string;
+  readonly name: string;
+  readonly description: string;
+}
+
+export interface CollectionInfo {
+  readonly id: string;
+  readonly databaseId: string;
+  readonly name: string;
+}
+
+export interface UserInfo {
+  readonly id: string;
+  readonly username: string;
+  readonly isSuperuser: boolean;
+}
+
+export interface GrantInfo {
+  readonly id: string;
+  readonly userId: string;
+  readonly databaseId: string;
+  readonly permission: string;
+}
+
+export interface CreatedDocumentToken {
+  readonly token: string;
+}
+
+export interface DocumentSnapshot<TState = unknown> {
+  readonly id: string;
+  readonly collectionId: string;
+  readonly state: TState;
+  readonly version: number;
+}

package/src/index.ts

@@ -0,0 +1,12 @@
+export { MimicSDK } from "./promise/MimicSDK";
+export { DatabaseHandle } from "./promise/DatabaseHandle";
+export { CollectionHandle } from "./promise/CollectionHandle";
+export type {
+  DatabaseInfo,
+  CollectionInfo,
+  UserInfo,
+  GrantInfo,
+  CreatedDocumentToken,
+  DocumentSnapshot,
+} from "./effect/types";
+export type { MimicClientConfig } from "./effect/HttpTransport";

package/src/promise/CollectionHandle.ts

@@ -0,0 +1,67 @@
+import type { ManagedRuntime } from "effect";
+import type { Primitive } from "@voidhash/mimic";
+import { CollectionHandle as EffectCollectionHandle } from "../effect/CollectionHandle";
+import type { MimicRpcRequirements } from "../effect/MimicSDK";
+import type { DocumentSnapshot, CreatedDocumentToken } from "../effect/types";
+
+export class CollectionHandle<TSchema extends Primitive.AnyPrimitive> {
+  readonly id: string;
+  readonly databaseId: string;
+  readonly schema: TSchema;
+  private readonly _effect: EffectCollectionHandle<TSchema>;
+  private readonly _runtime: ManagedRuntime.ManagedRuntime<MimicRpcRequirements, never>;
+
+  constructor(
+    id: string,
+    databaseId: string,
+    schema: TSchema,
+    runtime: ManagedRuntime.ManagedRuntime<MimicRpcRequirements, never>,
+  ) {
+    this.id = id;
+    this.databaseId = databaseId;
+    this.schema = schema;
+    this._effect = new EffectCollectionHandle(id, databaseId, schema);
+    this._runtime = runtime;
+  }
+
+  async create(
+    data: Primitive.InferSetInput<TSchema>,
+    options?: { id?: string },
+  ): Promise<DocumentSnapshot<Primitive.InferState<TSchema>>> {
+    return this._runtime.runPromise(this._effect.create(data, options));
+  }
+
+  async get(documentId: string): Promise<DocumentSnapshot<Primitive.InferState<TSchema>>> {
+    return this._runtime.runPromise(this._effect.get(documentId));
+  }
+
+  async update(
+    documentId: string,
+    data: Primitive.InferUpdateInput<TSchema>,
+  ): Promise<{ id: string; version: number }> {
+    return this._runtime.runPromise(this._effect.update(documentId, data));
+  }
+
+  async set(
+    documentId: string,
+    data: Primitive.InferSetInput<TSchema>,
+  ): Promise<{ id: string; version: number }> {
+    return this._runtime.runPromise(this._effect.set(documentId, data));
+  }
+
+  async delete(documentId: string): Promise<void> {
+    return this._runtime.runPromise(this._effect.delete(documentId)) as Promise<void>;
+  }
+
+  async list(): Promise<DocumentSnapshot<Primitive.InferState<TSchema>>[]> {
+    return this._runtime.runPromise(this._effect.list());
+  }
+
+  async createDocumentToken(
+    documentId: string,
+    permission: "read" | "write",
+    expiresInSeconds?: number,
+  ): Promise<CreatedDocumentToken> {
+    return this._runtime.runPromise(this._effect.createDocumentToken(documentId, permission, expiresInSeconds));
+  }
+}

package/src/promise/DatabaseHandle.ts

@@ -0,0 +1,50 @@
+import type { ManagedRuntime } from "effect";
+import type { Primitive } from "@voidhash/mimic";
+import { DatabaseHandle as EffectDatabaseHandle } from "../effect/DatabaseHandle";
+import type { MimicRpcRequirements } from "../effect/MimicSDK";
+import type { CollectionInfo } from "../effect/types";
+import { CollectionHandle } from "./CollectionHandle";
+
+export class DatabaseHandle {
+  readonly id: string;
+  readonly name: string;
+  readonly description: string;
+  private readonly _effect: EffectDatabaseHandle;
+  private readonly _runtime: ManagedRuntime.ManagedRuntime<MimicRpcRequirements, never>;
+
+  constructor(
+    id: string,
+    name: string,
+    description: string,
+    runtime: ManagedRuntime.ManagedRuntime<MimicRpcRequirements, never>,
+  ) {
+    this.id = id;
+    this.name = name;
+    this.description = description;
+    this._effect = new EffectDatabaseHandle(id, name, description);
+    this._runtime = runtime;
+  }
+
+  async createCollection<TSchema extends Primitive.AnyPrimitive>(
+    name: string,
+    schema: TSchema,
+  ): Promise<CollectionHandle<TSchema>> {
+    const info = await this._runtime.runPromise(this._effect.createCollection(name, schema));
+    return new CollectionHandle<TSchema>(info.id, info.databaseId, schema, this._runtime);
+  }
+
+  async listCollections(): Promise<CollectionInfo[]> {
+    return this._runtime.runPromise(this._effect.listCollections());
+  }
+
+  async deleteCollection(id: string): Promise<void> {
+    return this._runtime.runPromise(this._effect.deleteCollection(id)) as Promise<void>;
+  }
+
+  collection<TSchema extends Primitive.AnyPrimitive>(
+    id: string,
+    schema: TSchema,
+  ): CollectionHandle<TSchema> {
+    return new CollectionHandle<TSchema>(id, this.id, schema, this._runtime);
+  }
+}

package/src/promise/MimicSDK.ts

@@ -0,0 +1,69 @@
+import { ManagedRuntime } from "effect";
+import { MimicClientLayer, type MimicClientConfig } from "../effect/HttpTransport";
+import type { MimicRpcRequirements } from "../effect/MimicSDK";
+import * as EffectMimicSDK from "../effect/MimicSDK";
+import type { DatabaseInfo, UserInfo, GrantInfo } from "../effect/types";
+import { DatabaseHandle } from "./DatabaseHandle";
+
+export class MimicSDK {
+  private readonly _runtime: ManagedRuntime.ManagedRuntime<MimicRpcRequirements, never>;
+
+  private constructor(runtime: ManagedRuntime.ManagedRuntime<MimicRpcRequirements, never>) {
+    this._runtime = runtime;
+  }
+
+  static create(options: MimicClientConfig): MimicSDK {
+    const layer = MimicClientLayer(options);
+    const runtime = ManagedRuntime.make(layer) as ManagedRuntime.ManagedRuntime<MimicRpcRequirements, never>;
+    return new MimicSDK(runtime);
+  }
+
+  async createDatabase(options: { name: string; description?: string }): Promise<DatabaseHandle> {
+    const result = await this._runtime.runPromise(EffectMimicSDK.createDatabase(options));
+    return new DatabaseHandle(result.id, result.name, result.description, this._runtime);
+  }
+
+  async listDatabases(): Promise<DatabaseInfo[]> {
+    return this._runtime.runPromise(EffectMimicSDK.listDatabases());
+  }
+
+  async deleteDatabase(id: string): Promise<void> {
+    return this._runtime.runPromise(EffectMimicSDK.deleteDatabase(id)) as Promise<void>;
+  }
+
+  database(id: string, name = "", description = ""): DatabaseHandle {
+    return new DatabaseHandle(id, name, description, this._runtime);
+  }
+
+  async createUser(options: { username: string; password: string }): Promise<{ id: string; username: string }> {
+    return this._runtime.runPromise(EffectMimicSDK.createUser(options));
+  }
+
+  async listUsers(): Promise<UserInfo[]> {
+    return this._runtime.runPromise(EffectMimicSDK.listUsers());
+  }
+
+  async deleteUser(id: string): Promise<void> {
+    return this._runtime.runPromise(EffectMimicSDK.deleteUser(id)) as Promise<void>;
+  }
+
+  async grantPermission(options: {
+    userId: string;
+    databaseId: string;
+    permission: "read" | "write" | "admin";
+  }): Promise<void> {
+    return this._runtime.runPromise(EffectMimicSDK.grantPermission(options)) as Promise<void>;
+  }
+
+  async revokePermission(options: { userId: string; databaseId: string }): Promise<void> {
+    return this._runtime.runPromise(EffectMimicSDK.revokePermission(options)) as Promise<void>;
+  }
+
+  async listGrants(userId?: string): Promise<GrantInfo[]> {
+    return this._runtime.runPromise(EffectMimicSDK.listGrants(userId));
+  }
+
+  async dispose(): Promise<void> {
+    return this._runtime.dispose();
+  }
+}

package/src/promise/index.ts

@@ -0,0 +1,3 @@
+export { MimicSDK } from "./MimicSDK";
+export { DatabaseHandle } from "./DatabaseHandle";
+export { CollectionHandle } from "./CollectionHandle";