jazz-tools 0.7.0-alpha.0 → 0.7.0-alpha.11

package/src/coValueInterfaces.ts

@@ -1,105 +0,0 @@
-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

@@ -1,106 +0,0 @@
-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

@@ -1,284 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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>[]
-    > {}