jazz-tools 0.7.0-alpha.0

package/src/coValueInterfaces.ts

@@ -0,0 +1,105 @@
+import { RawCoID } from "cojson/src/ids";
+import {
+    AnyAccount,
+    ControlledAccount,
+    ControlledAccountCtx,
+} from "./coValues/account/account.js";
+import { CoValueCore } from "cojson";
+import { Effect, Stream } from "effect";
+import { UnavailableError } from "./errors.js";
+import { Schema } from "@effect/schema";
+import { AnyGroup } from "./coValues/group/group.js";
+import { SchemaWithInputAndOutput } from "./schemaHelpers.js";
+
+export type SubclassedConstructor<T> = {
+    new (...args: any[]): T;
+    type: string;
+};
+
+export interface CoValueConstructor<
+    Value extends CoValue = CoValue,
+    Type extends string = string,
+    Init = any,
+> {
+    readonly type: Type;
+
+    /** @category Construction and loading */
+    new (init: Init, options: { owner: AnyAccount | AnyGroup }): Value;
+
+    /** @ignore */
+    fromRaw(raw: Value["_raw"]): Value;
+
+    /** @category Construction and loading */
+    load<V extends Value>(
+        this: SubclassedConstructor<V>,
+        id: ID<V>,
+        options: { as: ControlledAccount, onProgress?: (progress: number) => void }
+    ): Promise<V | undefined>;
+
+    /** @category Construction and loading */
+    loadEf<V extends Value>(
+        this: SubclassedConstructor<V>,
+        id: ID<V>
+    ): Effect.Effect<V, UnavailableError, ControlledAccountCtx>;
+
+    /** @category Subscription */
+    subscribe<V extends Value>(
+        this: SubclassedConstructor<V>,
+        id: ID<V>,
+        options: { as: ControlledAccount },
+        onUpdate: (value: V) => void
+    ): () => void;
+
+    /** @category Subscription */
+    subscribeEf<V extends Value>(
+        this: SubclassedConstructor<V>,
+        id: ID<V>
+    ): Stream.Stream<V, UnavailableError, ControlledAccountCtx>;
+}
+
+/** @category Schemas & CoValues - Abstract interfaces */
+export interface CoValueSchema<
+    Self = any,
+    Value extends CoValue = CoValue,
+    Type extends string = string,
+    Init = any,
+> extends CoValueConstructor<Value, Type, Init>,
+        SchemaWithInputAndOutput<Self, Self> {}
+
+export function isCoValueSchema(value: any): value is CoValueSchema {
+    return value && value.type !== undefined;
+}
+
+export const inspect = Symbol.for("nodejs.util.inspect.custom");
+export type inspect = typeof inspect;
+
+/** @category Schemas & CoValues - Abstract interfaces */
+export interface CoValue<Type extends string = string, Raw = any> {
+    /** @category Value identity */
+    id: ID<this>;
+    /** @category Value identity */
+    _type: Type;
+    /** @category Collaboration */
+    _owner: AnyAccount | AnyGroup;
+    /** @category Subscription */
+    subscribe(listener: (update: this) => void): () => void;
+    /** @category Subscription */
+    subscribeEf(): Stream.Stream<this, UnavailableError, never>;
+    /** @category Internals */
+    _raw: Raw;
+    /** @category Internals */
+    _loadedAs: ControlledAccount;
+    /** @category Internals */
+    _schema: CoValueSchema;
+    /** @category Stringifying & inspection */
+    toJSON(): any[] | object;
+    /** @category Stringifying & inspection */
+    [inspect](): any;
+}
+
+export function isCoValue(value: any): value is CoValue {
+    return value && value._type !== undefined;
+}
+
+/** @category Schemas & CoValues - Abstract interfaces */
+export type ID<T> = RawCoID & { readonly __type: (_: never) => T };

package/src/coValues/account/account.ts

@@ -0,0 +1,106 @@
+import * as S from "@effect/schema/Schema";
+import {
+    CoValue,
+    ID,
+    CoValueSchema,
+    SubclassedConstructor,
+} from "../../coValueInterfaces.js";
+import { CoMap, CoMapSchema } from "../coMap/coMap.js";
+import {
+    AgentSecret,
+    InviteSecret,
+    Peer,
+    RawAccount,
+    RawControlledAccount,
+    Role,
+    SessionID,
+} from "cojson";
+import { AccountMigration } from "./migration.js";
+import { Context } from "effect";
+import { ValueRef } from "../../refs.js";
+import { SchemaWithInputAndOutput, SchemaWithOutput } from "../../schemaHelpers.js";
+
+export type ProfileSchema = CoMapSchema<any, {
+    name: S.Schema<string>
+}, any> & SchemaWithInputAndOutput<CoMap<{
+    name: S.Schema<string>
+}>>;
+
+export type RootSchema = CoValueSchema | S.Schema<null>;
+
+export interface AnyAccount<
+    P extends ProfileSchema = ProfileSchema,
+    R extends RootSchema = RootSchema,
+> extends CoValue<"Account", RawAccount> {
+    profile?: S.Schema.To<P>;
+    root?: S.Schema.To<R>;
+    isMe: boolean;
+    _refs: {
+        profile: ValueRef<S.Schema.To<P>>;
+        root: ValueRef<S.Schema.To<R>>;
+    };
+    myRole(): 'admin';
+}
+
+export function isAccount(value: CoValue): value is AnyAccount {
+    return value._type === "Account";
+}
+
+export function isControlledAccount(
+    value: CoValue
+): value is ControlledAccount {
+    return isAccount(value) && value.isMe;
+}
+
+export type ControlledAccount<
+    P extends ProfileSchema = ProfileSchema,
+    R extends RootSchema = RootSchema,
+> = AnyAccount<P, R> &
+    CoValue<"Account", RawControlledAccount> & {
+        isMe: true;
+
+        acceptInvite<V extends CoValueSchema>(
+            valueID: ID<S.Schema.To<V>>,
+            inviteSecret: InviteSecret,
+            valueSchema: V
+        ): Promise<S.Schema.To<V>>;
+
+        sessionID: SessionID;
+    };
+
+export interface AccountSchema<
+    Self = any,
+    P extends ProfileSchema = ProfileSchema,
+    R extends RootSchema = RootSchema,
+> extends CoValueSchema<Self, AnyAccount<P, R>, "Account", undefined> {
+    readonly [controlledAccountSym]: ControlledAccount<P, R>;
+
+    create<A extends AnyAccount<P, R>>(
+        this: SubclassedConstructor<A>,
+        options: {
+            name: string;
+            migration?: AccountMigration<AccountSchema<AnyAccount<P, R>, P, R>>;
+            initialAgentSecret?: AgentSecret;
+            peersToLoadFrom?: Peer[];
+        }
+    ): Promise<ControlledAccount<P, R>>;
+
+    become<A extends AnyAccount<P, R>>(
+        this: SubclassedConstructor<A>,
+        options: {
+            accountID: ID<AnyAccount<P, R>>;
+            accountSecret: AgentSecret;
+            sessionID: SessionID;
+            peersToLoadFrom: Peer[];
+            migration?: AccountMigration<AccountSchema<AnyAccount<P, R>, P, R>>;
+        }
+    ): Promise<ControlledAccount<P, R>>;
+}
+
+export const controlledAccountSym = Symbol("@jazz/controlledAccount");
+export type controlledAccountSym = typeof controlledAccountSym;
+
+export class ControlledAccountCtx extends Context.Tag("ControlledAccount")<
+    ControlledAccountCtx,
+    ControlledAccount
+>() {}

package/src/coValues/account/accountOf.ts

@@ -0,0 +1,284 @@
+import {
+    AgentSecret,
+    CoID,
+    InviteSecret,
+    LocalNode,
+    Peer,
+    RawAccount,
+    RawCoValue,
+    RawControlledAccount,
+    SessionID,
+} from "cojson";
+import {
+    ID,
+    CoValueSchema,
+    inspect,
+    CoValue,
+} from "../../coValueInterfaces.js";
+import { CoMapOf } from "../coMap/coMapOf.js";
+import {
+    AnyAccount,
+    AccountSchema,
+    ProfileSchema,
+    ControlledAccount,
+    controlledAccountSym,
+} from "./account.js";
+import * as S from "@effect/schema/Schema";
+import { AccountMigration } from "./migration.js";
+import { AST, Schema } from "@effect/schema";
+import { AnyGroup } from "../group/group.js";
+import { SharedCoValueConstructor } from "../construction.js";
+import { constructorOfSchemaSym } from "../resolution.js";
+import { pipeArguments } from "effect/Pipeable";
+import { ValueRef } from "../../refs.js";
+
+export function AccountOf<
+    P extends ProfileSchema,
+    R extends CoValueSchema | S.Schema<null>,
+>(fields: { profile: P; root: R }) {
+    class AccountOfProfileAndRoot
+        extends SharedCoValueConstructor
+        implements AnyAccount<P, R>
+    {
+        static get ast() {
+            return AST.setAnnotation(
+                Schema.instanceOf(this).ast,
+                constructorOfSchemaSym,
+                this
+            );
+        }
+        static [Schema.TypeId]: Schema.Schema.Variance<
+            AnyAccount<P, R> & AccountOfProfileAndRoot,
+            AnyAccount<P, R> & AccountOfProfileAndRoot,
+            never
+        >[Schema.TypeId];
+        static pipe() {
+            // eslint-disable-next-line prefer-rest-params
+            return pipeArguments(this, arguments);
+        }
+        static type = "Account" as const;
+        static [controlledAccountSym]: AccountOfProfileAndRoot &
+            ControlledAccount<P, R>;
+
+        id!: ID<this>;
+        _type!: "Account";
+        _owner!: AnyAccount | AnyGroup;
+        _refs!: AnyAccount<P, R>["_refs"];
+        _raw!: RawAccount | RawControlledAccount;
+        _loadedAs!: ControlledAccount;
+        _schema!: typeof AccountOfProfileAndRoot;
+
+        isMe: boolean;
+        sessionID?: SessionID;
+
+        constructor(
+            init: undefined,
+            options: { owner: ControlledAccount | AnyGroup | AnyAccount }
+        );
+        constructor(
+            init: undefined,
+            options: { fromRaw: RawAccount | RawControlledAccount }
+        );
+        constructor(
+            init: undefined,
+            options:
+                | { fromRaw: RawAccount | RawControlledAccount }
+                | { owner: ControlledAccount | AnyGroup | AnyAccount }
+        ) {
+            super();
+            if (!("fromRaw" in options)) {
+                throw new Error(
+                    "Can only construct account from raw or with .create()"
+                );
+            }
+            this.isMe =
+                options.fromRaw.id == options.fromRaw.core.node.account.id;
+
+            const refs = {
+                get profile() {
+                    const profileID = options.fromRaw.get("profile");
+                    return profileID && new ValueRef(
+                        profileID as unknown as ID<Schema.Schema.To<P>>,
+                        controlledAccountFromNode(options.fromRaw.core.node),
+                        fields.profile
+                    );
+                },
+                get root() {
+                    const rootID = options.fromRaw.get("root");
+                    return rootID && new ValueRef(
+                        rootID as unknown as ID<Schema.Schema.To<P>>,
+                        controlledAccountFromNode(options.fromRaw.core.node),
+                        fields.root
+                    );
+                },
+            };
+
+            Object.defineProperties(this, {
+                id: { value: options.fromRaw.id, enumerable: false },
+                _type: { value: "Account", enumerable: false },
+                _owner: { value: this, enumerable: false },
+                _refs: { value: refs, enumerable: false },
+                _raw: { value: options.fromRaw, enumerable: false },
+                _loadedAs: {
+                    get: () =>
+                        this.isMe
+                            ? this
+                            : controlledAccountFromNode(
+                                  options.fromRaw.core.node
+                              ),
+                    enumerable: false,
+                },
+                _schema: { value: AccountOfProfileAndRoot, enumerable: false },
+            });
+
+            if (this.isMe) {
+                (this as ControlledAccount).sessionID =
+                    options.fromRaw.core.node.currentSessionID;
+            }
+        }
+
+        static fromRaw(raw: RawAccount | RawControlledAccount) {
+            return new AccountOfProfileAndRoot(undefined, {
+                fromRaw: raw,
+            });
+        }
+
+        static async create(options: {
+            name: string;
+            migration?: AccountMigration<AccountSchema<AnyAccount<P, R>, P, R>>;
+            initialAgentSecret?: AgentSecret;
+            peersToLoadFrom?: Peer[];
+        }): Promise<AccountOfProfileAndRoot & ControlledAccount<P, R>> {
+            const { node } = await LocalNode.withNewlyCreatedAccount({
+                ...options,
+                migration:
+                    options.migration &&
+                    (async (rawAccount) => {
+                        const account = new AccountOfProfileAndRoot(undefined, {
+                            fromRaw: rawAccount,
+                        }) as AccountOfProfileAndRoot & ControlledAccount<P, R>;
+
+                        await options.migration!(account);
+                    }),
+            });
+
+            return new AccountOfProfileAndRoot(undefined, {
+                fromRaw: node.account as RawControlledAccount,
+            }) as AccountOfProfileAndRoot & ControlledAccount<P, R>;
+        }
+
+        static async become(options: {
+            accountID: ID<AnyAccount<P, R>>;
+            accountSecret: AgentSecret;
+            sessionID: SessionID;
+            peersToLoadFrom: Peer[];
+            migration?: AccountMigration<AccountSchema<AnyAccount<P, R>, P, R>>;
+        }): Promise<AccountOfProfileAndRoot & ControlledAccount<P, R>> {
+            const node = await LocalNode.withLoadedAccount({
+                accountID: options.accountID as unknown as CoID<RawAccount>,
+                accountSecret: options.accountSecret,
+                sessionID: options.sessionID,
+                peersToLoadFrom: options.peersToLoadFrom,
+                migration:
+                    options.migration &&
+                    (async (rawAccount) => {
+                        const account = new AccountOfProfileAndRoot(undefined, {
+                            fromRaw: rawAccount,
+                        }) as AccountOfProfileAndRoot & ControlledAccount<P, R>;
+
+                        await options.migration!(account);
+                    }),
+            });
+
+            return new AccountOfProfileAndRoot(undefined, {
+                fromRaw: node.account as RawControlledAccount,
+            }) as AccountOfProfileAndRoot & ControlledAccount<P, R>;
+        }
+
+        async acceptInvite<V extends CoValue>(
+            valueID: ID<V>,
+            inviteSecret: InviteSecret,
+            valueSchema: CoValueSchema<V, V>
+        ): Promise<V | undefined> {
+            if (!this.isMe) {
+                throw new Error("Only a controlled account can accept invites");
+            }
+
+            await (this._raw as RawControlledAccount).acceptInvite(
+                valueID as unknown as CoID<RawCoValue>,
+                inviteSecret
+            );
+
+            return valueSchema.load(valueID, { as: this as ControlledAccount });
+        }
+
+        get profile(): S.Schema.To<P> | undefined {
+            return this._refs.profile.accessFrom(this);
+        }
+
+        get root(): S.Schema.To<R> | undefined {
+            return this._refs.root.accessFrom(this);
+        }
+
+        myRole(): "admin" {
+            return "admin";
+        }
+
+        toJSON() {
+            return {
+                profile: this.profile?.toJSON(),
+                root: this.root?.toJSON(),
+            };
+        }
+
+        [inspect]() {
+            return this.toJSON();
+        }
+
+        static as<SubClass>() {
+            return this as unknown as AccountSchema<SubClass, P, R>;
+        }
+    }
+
+    return AccountOfProfileAndRoot as AccountSchema<
+        AccountOfProfileAndRoot & AnyAccount<P, R>,
+        P,
+        R
+    > & {
+        as<SubClass>(): AccountSchema<SubClass, P, R>;
+    };
+}
+
+export class BaseProfile extends CoMapOf({
+    name: S.string,
+}).as<BaseProfile>() {}
+
+export class Account extends AccountOf<
+    typeof BaseProfile,
+    Schema.Schema<null>
+>({
+    profile: BaseProfile,
+    root: S.null,
+}).as<Account>() {}
+
+const simpleControlledAccounts = new WeakMap<
+    RawControlledAccount,
+    Account & ControlledAccount
+>();
+
+export function controlledAccountFromNode(node: LocalNode): ControlledAccount {
+    if (!(node.account instanceof RawControlledAccount)) {
+        throw new Error("Expected a controlled account");
+    }
+    let simpleAccount;
+
+    if (simpleControlledAccounts.has(node.account)) {
+        simpleAccount = simpleControlledAccounts.get(node.account);
+    } else {
+        simpleAccount = Account.fromRaw(node.account) as Account &
+            ControlledAccount;
+        simpleControlledAccounts.set(node.account, simpleAccount);
+    }
+
+    return simpleAccount!;
+}

package/src/coValues/account/migration.ts

@@ -0,0 +1,12 @@
+import { AccountSchema, controlledAccountSym } from "./account.js";
+
+export type AccountMigration<A extends AccountSchema> = (
+    me: A[controlledAccountSym]
+) => void | Promise<void>;
+
+export function createAccountMigration<A extends AccountSchema>(
+    accountSchema: A,
+    migration: AccountMigration<A>
+): AccountMigration<A> {
+    return migration;
+}

package/src/coValues/coList/coList.ts

@@ -0,0 +1,57 @@
+import { JsonValue, RawCoList, CojsonInternalTypes } from "cojson";
+import { SchemaWithOutput } from "../../schemaHelpers.js";
+import { CoValue, CoValueSchema } from "../../coValueInterfaces.js";
+import { Schema } from "@effect/schema";
+import { ValueRef } from "../../refs.js";
+import { AnyAccount } from "../account/account.js";
+
+/**
+ *  @category Schemas & CoValues - CoList
+ */
+export interface CoListBase<
+    Item extends CoValueSchema | SchemaWithOutput<JsonValue>,
+> extends CoValue<"CoList", RawCoList> {
+    /** @category Collaboration metadata */
+    readonly _refs: {
+        [idx: number]: ValueRef<Schema.Schema.To<Item>>;
+        length: number;
+        [Symbol.iterator]: () => IterableIterator<
+            ValueRef<Schema.Schema.To<Item>>
+        >;
+    };
+    readonly _edits: {
+        [idx: number]: {
+            value?: Schema.Schema.To<Item>;
+            ref?: Item extends CoValueSchema
+                ? ValueRef<Schema.Schema.To<Item>>
+                : never;
+            by?: AnyAccount;
+            madeAt: Date;
+            tx: CojsonInternalTypes.TransactionID;
+        };
+    };
+}
+
+/**
+ *  @category Schemas & CoValues - CoList
+ */
+export type CoList<Item extends CoValueSchema | SchemaWithOutput<JsonValue>> =
+    Array<
+        Item extends CoValueSchema
+            ? Schema.Schema.To<Item> | undefined
+            : Schema.Schema.To<Item>
+    > &
+        CoListBase<Item>;
+
+/**
+ *  @category Schemas & CoValues - CoList
+ */
+export interface CoListSchema<
+    Self,
+    Item extends CoValueSchema | SchemaWithOutput<JsonValue>,
+> extends CoValueSchema<
+        Self,
+        CoList<Item>,
+        "CoList",
+        Schema.Schema.To<Item>[]
+    > {}