@dxos/echo 0.8.4-staging.ac66bdf99f → 0.9.0

package/src/internal/Type/echo-schema.ts

@@ -1,423 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import * as Schema from 'effect/Schema';
-import * as SchemaAST from 'effect/SchemaAST';
-
-import { invariant } from '@dxos/invariant';
-import { type ObjectId } from '@dxos/keys';
-
-import type * as Type from '../../Type';
-import { type SchemaMeta, SchemaMetaSymbol, type TypeAnnotation, getTypeAnnotation } from '../Annotation';
-import { ChangeId } from '../common/proxy';
-import { EntityKind, SchemaKindId } from '../common/types';
-import { type JsonSchemaType, toEffectSchema, toJsonSchema } from '../JsonSchema';
-import { type TypedObject, type TypedObjectPrototype, getSnapshot } from '../Obj';
-import {
-  addFieldsToSchema,
-  removeFieldsFromSchema,
-  setTypenameInSchema,
-  updateFieldNameInSchema,
-  updateFieldsInSchema,
-} from './manipulation';
-import { PersistentSchema } from './persistent-schema';
-
-/**
- * Base schema type.
- */
-// TODO(burdon): Merge with ImmutableSchema.
-export interface BaseSchema<A = any, I = any> extends TypedObject<A, I> {
-  // TODO(burdon): Different from mutable?
-  get readonly(): boolean;
-  // TODO(burdon): Change to external function.
-  get mutable(): EchoSchema<A, I>;
-  get snapshot(): Schema.Schema<A, I>;
-  get jsonSchema(): JsonSchemaType;
-}
-
-/**
- * Immutable schema type.
- * @deprecated Use `Schema.Schema.AnyNoContext` instead.
- */
-// TODO(burdon): Common abstract base class?
-export class ImmutableSchema<A = any, I = any> implements BaseSchema<A, I> {
-  private readonly _objectAnnotation: TypeAnnotation;
-  constructor(private readonly _schema: Schema.Schema<A, I>) {
-    this._objectAnnotation = getTypeAnnotation(this._schema)!;
-    invariant(this._objectAnnotation);
-  }
-
-  //
-  // Effect Schema (push to abstract base class).
-  //
-
-  public get [Schema.TypeId]() {
-    return schemaVariance;
-  }
-
-  public get Type() {
-    return this._schema.Type;
-  }
-
-  public get Encoded() {
-    return this._schema.Encoded;
-  }
-
-  public get Context() {
-    return this._schema.Context;
-  }
-
-  public get ast(): SchemaAST.AST {
-    return this._schema.ast;
-  }
-
-  public get annotations() {
-    return this._schema.annotations;
-  }
-
-  public get pipe() {
-    return this._schema.pipe;
-  }
-
-  //
-  // TypedObject
-  //
-
-  get kind(): EntityKind {
-    return this._objectAnnotation.kind;
-  }
-
-  get typename(): string {
-    return this._objectAnnotation.typename;
-  }
-
-  get version(): string {
-    return this._objectAnnotation.version;
-  }
-
-  //
-  // BaseSchema
-  //
-
-  get readonly(): boolean {
-    return true;
-  }
-
-  get snapshot(): Schema.Schema.AnyNoContext {
-    return this._schema;
-  }
-
-  // TODO(burdon): Change from getter since this is expensive.
-  get jsonSchema(): JsonSchemaType {
-    return toJsonSchema(this._schema);
-  }
-
-  get mutable(): EchoSchema {
-    throw new Error('Schema is readonly.');
-  }
-}
-
-/**
- * Defines an effect-schema for the `EchoSchema` type.
- *
- * This is here so that `EchoSchema` class can be used as a part of another schema definition (e.g., `ref(EchoSchema)`).
- */
-const EchoSchemaConstructor = (): TypedObjectPrototype => {
-  /**
-   * Return class definition satisfying Schema.Schema.
-   */
-  return class {
-    private static get _schema() {
-      // The field is DynamicEchoSchema in runtime, but is serialized as PersisentSchema in automerge.
-      return Schema.Union(PersistentSchema, Schema.instanceOf(EchoSchema)).annotations(
-        PersistentSchema.ast.annotations,
-      );
-    }
-
-    static readonly [Schema.TypeId] = schemaVariance;
-
-    static get ast() {
-      const schema = this._schema;
-      return schema.ast;
-    }
-
-    static get annotations() {
-      const schema = this._schema;
-      return schema.annotations.bind(schema);
-    }
-
-    static get pipe() {
-      const schema = this._schema;
-      return schema.pipe.bind(schema);
-    }
-  } as any;
-};
-
-export const isMutable = (schema: Schema.Schema.AnyNoContext): schema is EchoSchema => {
-  return schema instanceof EchoSchema;
-};
-
-// NOTE: Keep in this file.
-const schemaVariance = {
-  _A: (_: any) => _,
-  _I: (_: any) => _,
-  _R: (_: never) => _,
-};
-
-/**
- * Represents a schema that is persisted in the ECHO database.
- * Schema can me mutable or readonly (specified by the {@link EchoSchema.readonly} field).
- *
- * Schema that can be modified at runtime via the API.
- * Is an instance of effect-schema (`Schema.Schema.AnyNoContext`) so it can be used in the same way as a regular schema.
- * IMPORTANT: The schema AST will change reactively when the schema is updated, including synced updates from remote peers.
- *
- * The class constructor is a schema instance itself, and can be used in the echo object definitions:
- *
- * @example
- * ```ts
- * export class TableType extends Schema.Struct({...}).pipe(Type.object({ typename: 'com.example.type.table', version: '0.1.0' })){
- *   title: Schema.String,
- *   schema: Schema.optional(ref(EchoSchema)),
- *   props: Schema.mutable(S.Array(TablePropSchema)),
- * }) {}
- * ```
- *
- * The ECHO API will translate any references to PersistentSchema objects to be resolved as EchoSchema objects.
- */
-export class EchoSchema<A = any, I = any> extends EchoSchemaConstructor() implements BaseSchema<A, I> {
-  private _schema: Schema.Schema.AnyNoContext | undefined;
-  private _isDirty = true;
-
-  /**
-   * Schema kind key that marks this as an ECHO schema.
-   * Makes EchoSchema satisfy the Type.AnyObj type.
-   */
-  readonly [SchemaKindId]: EntityKind.Object = EntityKind.Object;
-
-  constructor(private readonly _persistentSchema: PersistentSchema) {
-    super();
-  }
-
-  //
-  // Effect Schema (push to abstract base class).
-  //
-
-  public get [Schema.TypeId]() {
-    return schemaVariance;
-  }
-
-  public get Type() {
-    return this._persistentSchema as A;
-  }
-
-  public get Encoded() {
-    return this._persistentSchema as I;
-  }
-
-  public get Context() {
-    const schema = this._getSchema();
-    return schema.Context;
-  }
-
-  public get ast() {
-    const schema = this._getSchema();
-    return schema.ast;
-  }
-
-  public get annotations() {
-    const schema = this._getSchema();
-    return schema.annotations.bind(schema);
-  }
-
-  public get pipe(): Schema.Schema.AnyNoContext['pipe'] {
-    const schema = this._getSchema();
-    return schema.pipe.bind(schema);
-  }
-
-  //
-  // BaseSchema
-  //
-
-  public get kind(): EntityKind.Object {
-    // Dynamic schemas are always object schemas.
-    return EntityKind.Object;
-  }
-
-  public get typename(): string {
-    return this._persistentSchema.typename;
-  }
-
-  public get version(): string {
-    return this._persistentSchema.version;
-  }
-
-  public get readonly(): boolean {
-    return false;
-  }
-
-  /**
-   * Returns an immutable schema snapshot of the current state of the schema.
-   */
-  public get snapshot(): Schema.Schema.AnyNoContext {
-    return this._getSchema();
-  }
-
-  /**
-   * Returns the JSON schema for the schema.
-   */
-  public get jsonSchema(): JsonSchemaType {
-    return this._persistentSchema.jsonSchema;
-  }
-
-  /**
-   * Returns a mutable schema.
-   */
-  public get mutable(): EchoSchema {
-    invariant(!this.readonly, 'Schema is not mutable');
-    return this;
-  }
-
-  //
-  // Mutable Schema
-  //
-
-  /**
-   * Id of the ECHO object containing the schema.
-   */
-  public get id(): ObjectId {
-    return this._persistentSchema.id;
-  }
-
-  /**
-   * Short name of the schema.
-   */
-  public get name(): string | undefined {
-    return this._persistentSchema.name;
-  }
-
-  public get [SchemaMetaSymbol](): SchemaMeta {
-    return { id: this.id, typename: this.typename, version: this._persistentSchema.version };
-  }
-
-  /**
-   * Reference to the underlying persistent schema object.
-   */
-  public get persistentSchema(): Type.PersistentType {
-    return this._persistentSchema as Type.PersistentType;
-  }
-
-  public getProperties(): SchemaAST.PropertySignature[] {
-    const ast = this._getSchema().ast;
-    invariant(SchemaAST.isTypeLiteral(ast));
-    return [...ast.propertySignatures].filter((p) => p.name !== 'id').map(unwrapOptionality);
-  }
-
-  //
-  // Mutation methods.
-  // TODO(burdon): Create separate interface for dynamic schema.
-  // TODO(burdon): Deprecate direct manipulation? Use JSONSchema directly.
-  //
-
-  /**
-   * @throws Error if the schema is readonly.
-   */
-  public updateTypename(typename: string): void {
-    const updated = setTypenameInSchema(this._getSchema(), typename);
-    this._change((schema) => {
-      schema.typename = typename;
-      schema.jsonSchema = toJsonSchema(updated);
-    });
-  }
-
-  /**
-   * @throws Error if the schema is readonly.
-   */
-  public addFields(fields: Schema.Struct.Fields): void {
-    const extended = addFieldsToSchema(this._getSchema(), fields);
-    this._change((schema) => {
-      schema.jsonSchema = toJsonSchema(extended);
-    });
-  }
-
-  /**
-   * @throws Error if the schema is readonly.
-   */
-  public updateFields(fields: Schema.Struct.Fields): void {
-    const updated = updateFieldsInSchema(this._getSchema(), fields);
-    this._change((schema) => {
-      schema.jsonSchema = toJsonSchema(updated);
-    });
-  }
-
-  /**
-   * @throws Error if the schema is readonly.
-   */
-  public updateFieldPropertyName({ before, after }: { before: PropertyKey; after: PropertyKey }): void {
-    const renamed = updateFieldNameInSchema(this._getSchema(), { before, after });
-    this._change((schema) => {
-      schema.jsonSchema = toJsonSchema(renamed);
-    });
-  }
-
-  /**
-   * @throws Error if the schema is readonly.
-   */
-  public removeFields(fieldNames: string[]): void {
-    const removed = removeFieldsFromSchema(this._getSchema(), fieldNames);
-    this._change((schema) => {
-      schema.jsonSchema = toJsonSchema(removed);
-    });
-  }
-
-  /**
-   * Wrapper for Obj.change that handles the change context for the persistent schema.
-   */
-  private _change(callback: (schema: PersistentSchema) => void): void {
-    const changeFn = (this._persistentSchema as any)[ChangeId];
-    if (changeFn) {
-      changeFn(callback);
-    } else {
-      callback(this._persistentSchema);
-    }
-  }
-
-  //
-  // Internals
-  //
-
-  /**
-   * Called by DatabaseSchemaRegistry on update.
-   */
-  _invalidate(): void {
-    this._isDirty = true;
-  }
-
-  /**
-   * Rebuilds this schema if it is dirty.
-   */
-  _rebuild(): void {
-    if (this._isDirty || this._schema == null) {
-      this._schema = toEffectSchema(getSnapshot(this._persistentSchema).jsonSchema);
-      this._isDirty = false;
-    }
-  }
-
-  _getSchema(): Schema.Schema.AnyNoContext {
-    this._rebuild();
-    return this._schema!;
-  }
-}
-
-// TODO(burdon): Move to effect.
-const unwrapOptionality = (property: SchemaAST.PropertySignature): SchemaAST.PropertySignature => {
-  if (!SchemaAST.isUnion(property.type)) {
-    return property;
-  }
-
-  return {
-    ...property,
-    type: property.type.types.find((type) => !SchemaAST.isUndefinedKeyword(type))!,
-  } as any;
-};

package/src/internal/Type/persistent-schema.ts

@@ -1,33 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import * as Schema from 'effect/Schema';
-
-import { IconAnnotation } from '../Annotation';
-import { LabelAnnotation, TypenameSchema, VersionSchema } from '../Annotation';
-import { EchoObjectSchema } from '../Entity';
-import { JsonSchemaType } from '../JsonSchema';
-
-/**
- * Persistent representation of a schema.
- */
-// TODO(burdon): Move.
-export const PersistentSchema = Schema.Struct({
-  name: Schema.optional(Schema.String),
-  typename: TypenameSchema,
-  version: VersionSchema,
-  jsonSchema: JsonSchemaType,
-}).pipe(
-  EchoObjectSchema({
-    typename: 'org.dxos.type.schema',
-    version: '0.1.0',
-  }),
-  LabelAnnotation.set(['name']),
-  IconAnnotation.set({
-    icon: 'ph--database--regular',
-    hue: 'green',
-  }),
-);
-
-export interface PersistentSchema extends Schema.Schema.Type<typeof PersistentSchema> {}