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

package/src/coValues/group/groupOf.ts

@@ -1,183 +0,0 @@
-import {
-    CoValueSchema,
-    ID,
-    inspect,
-    isCoValueSchema,
-} from "../../coValueInterfaces.js";
-import * as S from "@effect/schema/Schema";
-import { AnyGroup, GroupSchema } from "./group.js";
-import {
-    AnyAccount,
-    ControlledAccount,
-    isControlledAccount,
-} from "../account/account.js";
-import { AST, Schema } from "@effect/schema";
-import { constructorOfSchemaSym } from "../resolution.js";
-import { pipeArguments } from "effect/Pipeable";
-import { Everyone, RawGroup, Role } from "cojson";
-import { ValueRef } from "../../refs.js";
-import { controlledAccountFromNode } from "../account/accountOf.js";
-import { SharedCoValueConstructor } from "../construction.js";
-
-export function GroupOf<
-    P extends CoValueSchema | S.Schema<null>,
-    R extends CoValueSchema | S.Schema<null>,
->(fields: { profile: P; root: R }) {
-    class GroupOfProfileAndRoot
-        extends SharedCoValueConstructor
-        implements AnyGroup<P, R>
-    {
-        static get ast() {
-            return AST.setAnnotation(
-                Schema.instanceOf(this).ast,
-                constructorOfSchemaSym,
-                this
-            );
-        }
-        static [Schema.TypeId]: Schema.Schema.Variance<
-            AnyGroup<P, R> & GroupOfProfileAndRoot,
-            AnyGroup<P, R> & GroupOfProfileAndRoot,
-            never
-        >[Schema.TypeId];
-        static pipe() {
-            // eslint-disable-next-line prefer-rest-params
-            return pipeArguments(this, arguments);
-        }
-        static type = "Group" as const;
-
-        id!: ID<this>;
-        _type!: "Group";
-        _owner!: AnyAccount | AnyGroup;
-        _refs!: AnyGroup<P, R>["_refs"];
-        _raw!: RawGroup;
-        _loadedAs!: ControlledAccount;
-        _schema!: typeof GroupOfProfileAndRoot;
-
-        constructor(options: { owner: AnyAccount | AnyGroup });
-        constructor(init: any, options: { fromRaw: RawGroup });
-        constructor(init: undefined, options: { owner: AnyAccount | AnyGroup });
-        constructor(
-            init: undefined | { owner: AnyAccount | AnyGroup },
-            options?: { fromRaw: RawGroup } | { owner: AnyAccount | AnyGroup }
-        ) {
-            super();
-            let raw: RawGroup;
-
-            if (options && "fromRaw" in options) {
-                raw = options.fromRaw;
-            } else {
-                const initOwner = options?.owner || init?.owner;
-                if (!initOwner) throw new Error("No owner provided");
-                if (isControlledAccount(initOwner)) {
-                    const rawOwner = initOwner._raw;
-                    raw = rawOwner.createGroup();
-                } else {
-                    throw new Error(
-                        "Can only construct group as a controlled account"
-                    );
-                }
-            }
-
-            const refs = {
-                get profile() {
-                    if (isCoValueSchema(fields.profile)) {
-                        const profileID = raw.get("profile");
-                        return (
-                            profileID &&
-                            new ValueRef(
-                                profileID as unknown as ID<
-                                    Schema.Schema.To<typeof fields.profile>
-                                >,
-                                controlledAccountFromNode(raw.core.node),
-                                fields.profile
-                            )
-                        );
-                    }
-                },
-                get root() {
-                    if (isCoValueSchema(fields.root)) {
-                        const rootID = raw.get("root");
-                        return (
-                            rootID &&
-                            new ValueRef(
-                                rootID as unknown as ID<
-                                    Schema.Schema.To<typeof fields.root>
-                                >,
-                                controlledAccountFromNode(raw.core.node),
-                                fields.root
-                            )
-                        );
-                    }
-                },
-            };
-
-            Object.defineProperties(this, {
-                id: { value: raw.id, enumerable: false },
-                _type: { value: "Group", enumerable: false },
-                _owner: { value: this, enumerable: false },
-                _refs: { value: refs, enumerable: false },
-                _raw: { value: raw, enumerable: false },
-                _loadedAs: {
-                    get: () => controlledAccountFromNode(raw.core.node),
-                    enumerable: false,
-                },
-                _schema: { value: GroupOfProfileAndRoot, enumerable: false },
-            });
-        }
-
-        static fromRaw(raw: RawGroup) {
-            return new GroupOfProfileAndRoot(undefined, {
-                fromRaw: raw,
-            });
-        }
-
-        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);
-        }
-
-        addMember(member: AnyAccount | Everyone, role: Role) {
-            this._raw.addMember(
-                typeof member === "string" ? member : member._raw,
-                role
-            );
-
-            return this;
-        }
-
-        myRole(): Role | undefined {
-            return this._raw.myRole();
-        }
-
-        toJSON() {
-            return {
-                co: {
-                    id: this.id,
-                    type: this._type,
-                },
-                profile: this.profile?.toJSON(),
-                root: this.root?.toJSON(),
-            };
-        }
-
-        [inspect]() {
-            return this.toJSON();
-        }
-
-        static as<SubClass>() {
-            return this as unknown as GroupSchema<SubClass, P, R>;
-        }
-    }
-
-    return GroupOfProfileAndRoot as GroupSchema<GroupOfProfileAndRoot, P, R> & {
-        as<SubClass>(): GroupSchema<SubClass, P, R>;
-    };
-}
-
-export class Group extends GroupOf({
-    profile: S.null,
-    root: S.null,
-}).as<Group>() {}

package/src/coValues/resolution.ts

@@ -1,111 +0,0 @@
-import { Schema, AST } from "@effect/schema";
-import { RawCoValue } from "cojson";
-import { CoValue, CoValueSchema } from "../coValueInterfaces.js";
-
-// TODO: can we get rid of this because effect schema already has an annotation for the constructor?
-export const constructorOfSchemaSym = Symbol.for("@jazz/constructorOfSymbol");
-export type constructorOfSchemaSym = typeof constructorOfSchemaSym;
-
-export function propertyIsCoValueSchema(
-    prop:
-        | Schema.Schema<any>
-        | Schema.PropertySignature<any, boolean, any, boolean, never>
-): prop is CoValueSchema {
-    if ("propertySignatureAST" in prop) {
-        return astIsCoValueSchema(
-            (prop.propertySignatureAST as { from: AST.AST }).from
-        );
-    } else {
-        return astIsCoValueSchema((prop as Schema.Schema<unknown>).ast);
-    }
-}
-
-function astIsCoValueSchema(ast: AST.AST): boolean {
-    if (
-        (ast._tag === "Declaration") &&
-        ast.annotations[constructorOfSchemaSym]
-    ) {
-        return true;
-    } else if (ast._tag === "Union") {
-        return ast.types.every(
-            (member) =>
-                member._tag === "UndefinedKeyword" || astIsCoValueSchema(member)
-        );
-    } else if (
-        ast._tag === "BooleanKeyword" ||
-        ast._tag === "NumberKeyword" ||
-        ast._tag === "StringKeyword" ||
-        ast._tag === "Literal" ||
-        ast._tag === "Tuple"
-    ) {
-        return false;
-    } else if (ast._tag === "Refinement") {
-        return astIsCoValueSchema(ast.from);
-    } else if (ast._tag === "Transform") {
-        return astIsCoValueSchema(ast.from);
-    } else {
-        throw new Error(
-            `astIsCoValueSchema can't yet handle ${ast._tag}: ${JSON.stringify(
-                ast
-            )}`
-        );
-    }
-}
-
-export function getCoValueConstructorInProperty(
-    prop:
-        | Schema.Schema<unknown>
-        | Schema.PropertySignature<unknown, boolean, unknown, boolean, never>,
-    rawValue: RawCoValue
-):
-    | (new (init: undefined, options: { fromRaw: RawCoValue }) => CoValue)
-    | undefined {
-    if ("propertySignatureAST" in prop) {
-        return getCoValueConstructorInAST(
-            (prop.propertySignatureAST as { from: AST.AST }).from,
-            rawValue
-        );
-    } else {
-        return getCoValueConstructorInAST(
-            (prop as Schema.Schema<unknown>).ast,
-            rawValue
-        );
-    }
-}
-
-// TODO (optimization): make this meta, so this creates a tailor-made function that will take a RawCoValue at call time
-function getCoValueConstructorInAST(
-    ast: AST.AST,
-    rawValue: RawCoValue
-):
-    | (new (init: undefined, options: { fromRaw: RawCoValue }) => CoValue)
-    | undefined {
-    if (
-        (ast._tag === "Declaration") &&
-        ast.annotations[constructorOfSchemaSym]
-    ) {
-        return ast.annotations[constructorOfSchemaSym] as new (
-            init: undefined,
-            options: { fromRaw: RawCoValue }
-        ) => CoValue;
-    } else if (ast._tag === "Union" && ast.types.length === 2) {
-        const [a, b] = ast.types;
-        if (a._tag === "UndefinedKeyword") {
-            return getCoValueConstructorInAST(b, rawValue);
-        } else if (b._tag === "UndefinedKeyword") {
-            return getCoValueConstructorInAST(a, rawValue);
-        } else {
-            throw new Error(
-                `getCoValueConstructorInAST can't yet handle Union of: ${JSON.stringify(
-                    ast.types
-                )}`
-            );
-        }
-    } else {
-        throw new Error(
-            `getCoValueConstructorInAST can't yet handle ${
-                ast._tag
-            }: ${JSON.stringify(ast)}`
-        );
-    }
-}

package/src/schemaHelpers.ts

@@ -1,72 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { AST } from "@effect/schema";
-import * as S from "@effect/schema/Schema";
-
-export type SchemaWithOutput<I> = S.Schema<any, any, never> & {
-    [S.TypeId]: {
-        _I: (_: any) => I;
-    };
-};
-
-export type SchemaWithInputAndOutput<A, I = A> = S.Schema<any, any, never> & {
-    [S.TypeId]: {
-        _A: (_: any) => A;
-        _I: (_: any) => I;
-    };
-};
-
-export type PropertySignatureWithOutput<I> = S.PropertySignature<
-    any,
-    boolean,
-    any,
-    boolean,
-    never
-> & {
-    [S.TypeId]: {
-        _I: (_: any) => I | undefined;
-    };
-};
-
-export type PropertySignatureWithInputAndOutput<I, A> = S.PropertySignature<
-    any,
-    boolean,
-    any,
-    boolean,
-    never
-> & {
-    [S.TypeId]: {
-        _A: (_: any) => A | undefined;
-        _I: (_: any) => I | undefined;
-    };
-};
-
-export type PropDef<I> =
-    | S.Schema<I>
-    | S.PropertySignature<I, boolean, I, boolean, never>;
-
-export function CoSchema<Raw extends S.Schema<any>>(
-    raw: Raw
-): Raw & S.Schema<Raw, any, any> {
-    return raw as any;
-}
-
-export function propSigToSchema<
-    S extends S.Schema<any> | PropertySignatureWithInputAndOutput<any, any>,
->(
-    propSig: S
-): S extends S.Schema<any>
-    ? S
-    : S extends PropertySignatureWithInputAndOutput<infer A, infer I>
-      ? S.Schema<A, I>
-      : never {
-    if ("ast" in propSig) {
-        return propSig as any;
-    } else {
-        const ast = (
-            propSig as unknown as {
-                propertySignatureAST: { from: AST.AST };
-            }
-        ).propertySignatureAST;
-        return S.make<any, unknown, never>(ast.from) as any;
-    }
-}

package/src/tests/types.test.ts

@@ -1,37 +0,0 @@
-import { Account, Co, ImageDefinition, S, jazzReady } from "..";
-import { describe, test, beforeEach, expectTypeOf } from "vitest";
-import { ValueRef } from "../refs";
-import { webcrypto } from "node:crypto";
-
-if (!("crypto" in globalThis)) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    (globalThis as any).crypto = webcrypto;
-}
-
-beforeEach(async () => {
-    await jazzReady;
-});
-
-class TestMap extends Co.map({
-    name: S.string,
-    image: Co.media.imageDef,
-    maybeImage: S.optional(Co.media.imageDef),
-}).as<TestMap>() {}
-
-describe("CoMap type tests", () => {
-    test("Optional field refs work", async () => {
-        const me = await Account.create({
-            name: "Hermes Puggington",
-        });
-
-        const map = new TestMap({
-            name: "Hermes",
-            image: new ImageDefinition({
-                originalSize: [100, 100],
-                placeholderDataURL: "data:image/png;base64,",
-            }, { owner: me }),
-        }, {owner: me});
-        expectTypeOf(map._refs.image).toMatchTypeOf<ValueRef<ImageDefinition>>();
-        expectTypeOf(map._refs.maybeImage).toMatchTypeOf<ValueRef<ImageDefinition>>();
-    })
-})