@yorkie-js/react 0.6.17 → 0.6.20

package/dist/yorkie-js-react.es.js

@@ -5,7 +5,7 @@ var _a, _b, _c, _d, _e, _f, _g, _h, _i;
 import { jsx } from "react/jsx-runtime";
 import { createContext, useMemo, useState, useEffect, useContext, useCallback } from "react";
 const name$1 = "@yorkie-js/react";
-const version$1 = "0.6.17";
+const version$1 = "0.6.20";
 const pkg$1 = {
   name: name$1,
   version: version$1
@@ -6456,6 +6456,10 @@ const _DocumentSummary = class _DocumentSummary extends Message {
      * @generated from field: yorkie.v1.DocSize document_size = 8;
      */
     __publicField(this, "documentSize");
+    /**
+     * @generated from field: string schema_key = 9;
+     */
+    __publicField(this, "schemaKey", "");
     /**
      * @generated from field: google.protobuf.Timestamp created_at = 4;
      */
@@ -6515,6 +6519,13 @@ __publicField(_DocumentSummary, "fields", proto3.util.newFieldList(() => [
     /* ScalarType.INT32 */
   },
   { no: 8, name: "document_size", kind: "message", T: DocSize },
+  {
+    no: 9,
+    name: "schema_key",
+    kind: "scalar",
+    T: 9
+    /* ScalarType.STRING */
+  },
   { no: 4, name: "created_at", kind: "message", T: Timestamp },
   { no: 5, name: "accessed_at", kind: "message", T: Timestamp },
   { no: 6, name: "updated_at", kind: "message", T: Timestamp }
@@ -6570,9 +6581,9 @@ let Presence$1 = (_g = class extends Message {
   constructor(data) {
     super();
     /**
-     * @generated from field: repeated string data = 1;
+     * @generated from field: map<string, string> data = 1;
      */
-    __publicField(this, "data", []);
+    __publicField(this, "data", {});
     proto3.util.initPartial(data, this);
   }
   static fromBinary(bytes, options) {
@@ -6588,7 +6599,11 @@ let Presence$1 = (_g = class extends Message {
     return proto3.util.equals(_g, a, b);
   }
 }, __publicField(_g, "runtime", proto3), __publicField(_g, "typeName", "yorkie.v1.Presence"), __publicField(_g, "fields", proto3.util.newFieldList(() => [
-  { no: 1, name: "data", kind: "scalar", T: 9, repeated: true }
+  { no: 1, name: "data", kind: "map", K: 9, V: {
+    kind: "scalar",
+    T: 9
+    /* ScalarType.STRING */
+  } }
 ])), _g);
 let Checkpoint$1 = (_h = class extends Message {
   constructor(data) {
@@ -6900,6 +6915,128 @@ __publicField(_DocSize, "fields", proto3.util.newFieldList(() => [
   { no: 2, name: "gc", kind: "message", T: DataSize }
 ]));
 let DocSize = _DocSize;
+const _Schema = class _Schema extends Message {
+  constructor(data) {
+    super();
+    /**
+     * @generated from field: string id = 1;
+     */
+    __publicField(this, "id", "");
+    /**
+     * @generated from field: string name = 2;
+     */
+    __publicField(this, "name", "");
+    /**
+     * @generated from field: int32 version = 3;
+     */
+    __publicField(this, "version", 0);
+    /**
+     * @generated from field: string body = 4;
+     */
+    __publicField(this, "body", "");
+    /**
+     * @generated from field: repeated yorkie.v1.Rule rules = 5;
+     */
+    __publicField(this, "rules", []);
+    /**
+     * @generated from field: google.protobuf.Timestamp created_at = 6;
+     */
+    __publicField(this, "createdAt");
+    proto3.util.initPartial(data, this);
+  }
+  static fromBinary(bytes, options) {
+    return new _Schema().fromBinary(bytes, options);
+  }
+  static fromJson(jsonValue, options) {
+    return new _Schema().fromJson(jsonValue, options);
+  }
+  static fromJsonString(jsonString, options) {
+    return new _Schema().fromJsonString(jsonString, options);
+  }
+  static equals(a, b) {
+    return proto3.util.equals(_Schema, a, b);
+  }
+};
+__publicField(_Schema, "runtime", proto3);
+__publicField(_Schema, "typeName", "yorkie.v1.Schema");
+__publicField(_Schema, "fields", proto3.util.newFieldList(() => [
+  {
+    no: 1,
+    name: "id",
+    kind: "scalar",
+    T: 9
+    /* ScalarType.STRING */
+  },
+  {
+    no: 2,
+    name: "name",
+    kind: "scalar",
+    T: 9
+    /* ScalarType.STRING */
+  },
+  {
+    no: 3,
+    name: "version",
+    kind: "scalar",
+    T: 5
+    /* ScalarType.INT32 */
+  },
+  {
+    no: 4,
+    name: "body",
+    kind: "scalar",
+    T: 9
+    /* ScalarType.STRING */
+  },
+  { no: 5, name: "rules", kind: "message", T: Rule, repeated: true },
+  { no: 6, name: "created_at", kind: "message", T: Timestamp }
+]));
+let Schema = _Schema;
+const _Rule = class _Rule extends Message {
+  constructor(data) {
+    super();
+    /**
+     * @generated from field: string path = 1;
+     */
+    __publicField(this, "path", "");
+    /**
+     * @generated from field: string type = 2;
+     */
+    __publicField(this, "type", "");
+    proto3.util.initPartial(data, this);
+  }
+  static fromBinary(bytes, options) {
+    return new _Rule().fromBinary(bytes, options);
+  }
+  static fromJson(jsonValue, options) {
+    return new _Rule().fromJson(jsonValue, options);
+  }
+  static fromJsonString(jsonString, options) {
+    return new _Rule().fromJsonString(jsonString, options);
+  }
+  static equals(a, b) {
+    return proto3.util.equals(_Rule, a, b);
+  }
+};
+__publicField(_Rule, "runtime", proto3);
+__publicField(_Rule, "typeName", "yorkie.v1.Rule");
+__publicField(_Rule, "fields", proto3.util.newFieldList(() => [
+  {
+    no: 1,
+    name: "path",
+    kind: "scalar",
+    T: 9
+    /* ScalarType.STRING */
+  },
+  {
+    no: 2,
+    name: "type",
+    kind: "scalar",
+    T: 9
+    /* ScalarType.STRING */
+  }
+]));
+let Rule = _Rule;
 const _ActivateClientRequest = class _ActivateClientRequest extends Message {
   constructor(data) {
     super();
@@ -7044,6 +7181,10 @@ const _AttachDocumentRequest = class _AttachDocumentRequest extends Message {
      * @generated from field: yorkie.v1.ChangePack change_pack = 2;
      */
     __publicField(this, "changePack");
+    /**
+     * @generated from field: string schema_key = 3;
+     */
+    __publicField(this, "schemaKey", "");
     proto3.util.initPartial(data, this);
   }
   static fromBinary(bytes, options) {
@@ -7069,7 +7210,14 @@ __publicField(_AttachDocumentRequest, "fields", proto3.util.newFieldList(() => [
     T: 9
     /* ScalarType.STRING */
   },
-  { no: 2, name: "change_pack", kind: "message", T: ChangePack$1 }
+  { no: 2, name: "change_pack", kind: "message", T: ChangePack$1 },
+  {
+    no: 3,
+    name: "schema_key",
+    kind: "scalar",
+    T: 9
+    /* ScalarType.STRING */
+  }
 ]));
 let AttachDocumentRequest = _AttachDocumentRequest;
 const _AttachDocumentResponse = class _AttachDocumentResponse extends Message {
@@ -7079,14 +7227,18 @@ const _AttachDocumentResponse = class _AttachDocumentResponse extends Message {
      * @generated from field: string document_id = 1;
      */
     __publicField(this, "documentId", "");
+    /**
+     * @generated from field: yorkie.v1.ChangePack change_pack = 2;
+     */
+    __publicField(this, "changePack");
     /**
      * @generated from field: int32 max_size_per_document = 3;
      */
     __publicField(this, "maxSizePerDocument", 0);
     /**
-     * @generated from field: yorkie.v1.ChangePack change_pack = 2;
+     * @generated from field: repeated yorkie.v1.Rule schema_rules = 4;
      */
-    __publicField(this, "changePack");
+    __publicField(this, "schemaRules", []);
     proto3.util.initPartial(data, this);
   }
   static fromBinary(bytes, options) {
@@ -7112,6 +7264,7 @@ __publicField(_AttachDocumentResponse, "fields", proto3.util.newFieldList(() =>
     T: 9
     /* ScalarType.STRING */
   },
+  { no: 2, name: "change_pack", kind: "message", T: ChangePack$1 },
   {
     no: 3,
     name: "max_size_per_document",
@@ -7119,7 +7272,7 @@ __publicField(_AttachDocumentResponse, "fields", proto3.util.newFieldList(() =>
     T: 5
     /* ScalarType.INT32 */
   },
-  { no: 2, name: "change_pack", kind: "message", T: ChangePack$1 }
+  { no: 4, name: "schema_rules", kind: "message", T: Rule, repeated: true }
 ]));
 let AttachDocumentResponse = _AttachDocumentResponse;
 const _DetachDocumentRequest = class _DetachDocumentRequest extends Message {
@@ -7890,6 +8043,7 @@ var Code = /* @__PURE__ */ ((Code2) => {
   Code2["ErrDocumentNotDetached"] = "ErrDocumentNotDetached";
   Code2["ErrDocumentRemoved"] = "ErrDocumentRemoved";
   Code2["ErrDocumentSizeExceedsLimit"] = "ErrDocumentSizeExceedsLimit";
+  Code2["ErrDocumentSchemaValidationFailed"] = "ErrDocumentSchemaValidationFailed";
   Code2["ErrInvalidObjectKey"] = "ErrInvalidObjectKey";
   Code2["ErrInvalidArgument"] = "ErrInvalidArgument";
   Code2["ErrNotInitialized"] = "ErrNotInitialized";
@@ -10501,8 +10655,8 @@ class CRDTArray extends CRDTContainer {
   /**
    * `insertAfter` adds a new node after the the given node.
    */
-  insertAfter(prevCreatedAt, value) {
-    this.elements.insertAfter(prevCreatedAt, value);
+  insertAfter(prevCreatedAt, value, executedAt) {
+    this.elements.insertAfter(prevCreatedAt, value, executedAt);
   }
   /**
    * `moveAfter` moves the given `createdAt` element after the `prevCreatedAt`.
@@ -10670,6 +10824,84 @@ class CRDTArray extends CRDTContainer {
     return clone;
   }
 }
+class AddOperation extends Operation {
+  constructor(parentCreatedAt, prevCreatedAt, value, executedAt) {
+    super(parentCreatedAt, executedAt);
+    __publicField(this, "prevCreatedAt");
+    __publicField(this, "value");
+    this.prevCreatedAt = prevCreatedAt;
+    this.value = value;
+  }
+  /**
+   * `create` creates a new instance of AddOperation.
+   */
+  static create(parentCreatedAt, prevCreatedAt, value, executedAt) {
+    return new AddOperation(parentCreatedAt, prevCreatedAt, value, executedAt);
+  }
+  /**
+   * `execute` executes this operation on the given `CRDTRoot`.
+   */
+  execute(root) {
+    const parentObject = root.findByCreatedAt(this.getParentCreatedAt());
+    if (!parentObject) {
+      throw new YorkieError(
+        Code.ErrInvalidArgument,
+        `fail to find ${this.getParentCreatedAt()}`
+      );
+    }
+    if (!(parentObject instanceof CRDTArray)) {
+      throw new YorkieError(
+        Code.ErrInvalidArgument,
+        `fail to execute, only array can execute add`
+      );
+    }
+    const array = parentObject;
+    const value = this.value.deepcopy();
+    array.insertAfter(this.prevCreatedAt, value, this.getExecutedAt());
+    root.registerElement(value, array);
+    return {
+      opInfos: [
+        {
+          type: "add",
+          path: root.createPath(this.getParentCreatedAt()),
+          index: Number(array.subPathOf(this.getEffectedCreatedAt()))
+        }
+      ],
+      reverseOp: this.toReverseOperation()
+    };
+  }
+  toReverseOperation() {
+    const reverseOp = RemoveOperation.create(
+      this.getParentCreatedAt(),
+      this.value.getCreatedAt()
+    );
+    return reverseOp;
+  }
+  /**
+   * `getEffectedCreatedAt` returns the creation time of the effected element.
+   */
+  getEffectedCreatedAt() {
+    return this.value.getCreatedAt();
+  }
+  /**
+   * `toTestString` returns a string containing the meta data.
+   */
+  toTestString() {
+    return `${this.getParentCreatedAt().toTestString()}.ADD.${this.value.toJSON()}`;
+  }
+  /**
+   * `getPrevCreatedAt` returns the creation time of previous element.
+   */
+  getPrevCreatedAt() {
+    return this.prevCreatedAt;
+  }
+  /**
+   * `getValue` returns the value of this operation.
+   */
+  getValue() {
+    return this.value;
+  }
+}
 class RemoveOperation extends Operation {
   constructor(parentCreatedAt, createdAt, executedAt) {
     super(parentCreatedAt, executedAt);
@@ -10734,6 +10966,19 @@ class RemoveOperation extends Operation {
    * `toReverseOperation` returns the reverse operation of this operation.
    */
   toReverseOperation(parentObject) {
+    if (parentObject instanceof CRDTArray) {
+      const value = parentObject.getByID(this.createdAt);
+      if (value !== void 0) {
+        const prevCreatedAt = parentObject.getPrevCreatedAt(
+          this.createdAt
+        );
+        return AddOperation.create(
+          this.getParentCreatedAt(),
+          prevCreatedAt,
+          value.deepcopy()
+        );
+      }
+    }
     if (parentObject instanceof CRDTObject) {
       const key = parentObject.subPathOf(this.createdAt);
       if (key !== void 0) {
@@ -10872,76 +11117,6 @@ class SetOperation extends Operation {
     return this.value;
   }
 }
-class AddOperation extends Operation {
-  constructor(parentCreatedAt, prevCreatedAt, value, executedAt) {
-    super(parentCreatedAt, executedAt);
-    __publicField(this, "prevCreatedAt");
-    __publicField(this, "value");
-    this.prevCreatedAt = prevCreatedAt;
-    this.value = value;
-  }
-  /**
-   * `create` creates a new instance of AddOperation.
-   */
-  static create(parentCreatedAt, prevCreatedAt, value, executedAt) {
-    return new AddOperation(parentCreatedAt, prevCreatedAt, value, executedAt);
-  }
-  /**
-   * `execute` executes this operation on the given `CRDTRoot`.
-   */
-  execute(root) {
-    const parentObject = root.findByCreatedAt(this.getParentCreatedAt());
-    if (!parentObject) {
-      throw new YorkieError(
-        Code.ErrInvalidArgument,
-        `fail to find ${this.getParentCreatedAt()}`
-      );
-    }
-    if (!(parentObject instanceof CRDTArray)) {
-      throw new YorkieError(
-        Code.ErrInvalidArgument,
-        `fail to execute, only array can execute add`
-      );
-    }
-    const array = parentObject;
-    const value = this.value.deepcopy();
-    array.insertAfter(this.prevCreatedAt, value);
-    root.registerElement(value, array);
-    return {
-      opInfos: [
-        {
-          type: "add",
-          path: root.createPath(this.getParentCreatedAt()),
-          index: Number(array.subPathOf(this.getEffectedCreatedAt()))
-        }
-      ]
-    };
-  }
-  /**
-   * `getEffectedCreatedAt` returns the creation time of the effected element.
-   */
-  getEffectedCreatedAt() {
-    return this.value.getCreatedAt();
-  }
-  /**
-   * `toTestString` returns a string containing the meta data.
-   */
-  toTestString() {
-    return `${this.getParentCreatedAt().toTestString()}.ADD.${this.value.toJSON()}`;
-  }
-  /**
-   * `getPrevCreatedAt` returns the creation time of previous element.
-   */
-  getPrevCreatedAt() {
-    return this.prevCreatedAt;
-  }
-  /**
-   * `getValue` returns the value of this operation.
-   */
-  getValue() {
-    return this.value;
-  }
-}
 class MoveOperation extends Operation {
   constructor(parentCreatedAt, prevCreatedAt, createdAt, executedAt) {
     super(parentCreatedAt, executedAt);
@@ -10979,6 +11154,7 @@ class MoveOperation extends Operation {
       );
     }
     const array = parentObject;
+    const reverseOp = this.toReverseOperation(array);
     const previousIndex = Number(array.subPathOf(this.createdAt));
     array.moveAfter(this.prevCreatedAt, this.createdAt, this.getExecutedAt());
     const index = Number(array.subPathOf(this.createdAt));
@@ -10990,9 +11166,18 @@ class MoveOperation extends Operation {
           index,
           previousIndex
         }
-      ]
+      ],
+      reverseOp
     };
   }
+  toReverseOperation(array) {
+    const preservePrevCreatedAt = array.getPrevCreatedAt(this.createdAt);
+    return MoveOperation.create(
+      this.getParentCreatedAt(),
+      preservePrevCreatedAt,
+      this.createdAt
+    );
+  }
   /**
    * `getEffectedCreatedAt` returns the creation time of the effected element.
    */
@@ -15941,10 +16126,9 @@ class TreeStyleOperation extends Operation {
 }
 function toPresence(presence) {
   const pbPresence = new Presence$1();
-  const pbDataArray = pbPresence.data;
+  const pbDataMap = pbPresence.data;
   for (const [key, value] of Object.entries(presence)) {
-    pbDataArray.push(key);
-    pbDataArray.push(JSON.stringify(value));
+    pbDataMap[key] = JSON.stringify(value);
   }
   return pbPresence;
 }
@@ -16506,11 +16690,9 @@ function fromTimeTicket(pbTimeTicket) {
 }
 function fromPresence(pbPresence) {
   const data = {};
-  for (let i = 0; i < pbPresence.data.length; i += 2) {
-    const key = pbPresence.data[i];
-    const value = pbPresence.data[i + 1];
+  Object.entries(pbPresence.data).forEach(([key, value]) => {
     data[key] = JSON.parse(value);
-  }
+  });
   return data;
 }
 function fromPresenceChange(pbPresenceChange) {
@@ -16946,6 +17128,14 @@ function fromElement(pbElement) {
     throw new YorkieError(Code.ErrUnimplemented, `unimplemented element`);
   }
 }
+function fromSchemaRules(pbRules) {
+  return pbRules.map((pbRule) => {
+    return {
+      path: pbRule.path,
+      type: pbRule.type
+    };
+  });
+}
 function bytesToSnapshot(bytes) {
   if (!bytes) {
     return {
@@ -17043,7 +17233,8 @@ const converter = {
   bytesToChangeID,
   bytesToOperation,
   versionVectorToHex,
-  hexToVersionVector
+  hexToVersionVector,
+  fromSchemaRules
 };
 var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
   LogLevel2[LogLevel2["Trivial"] = 0] = "Trivial";
@@ -17203,6 +17394,156 @@ class Attachment {
     this.watchLoopTimerID = void 0;
   }
 }
+function validateYorkieRuleset(data, ruleset) {
+  const errors = [];
+  for (const rule of ruleset) {
+    const value = getValueByPath(data, rule.path);
+    const result = validateValue(value, rule);
+    if (!result.valid) {
+      for (const error of result.errors || []) {
+        errors.push(error);
+      }
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function getValueByPath(obj, path) {
+  if (!path.startsWith("$")) {
+    throw new Error(`Path must start with $, got ${path}`);
+  }
+  const keys = path.split(".");
+  let current = obj;
+  for (let i = 1; i < keys.length; i++) {
+    const key = keys[i];
+    if (!(current instanceof CRDTObject)) {
+      return void 0;
+    }
+    current = current.get(key);
+  }
+  return current;
+}
+function validateValue(value, rule) {
+  switch (rule.type) {
+    case "string":
+    case "boolean":
+    case "integer":
+    case "double":
+    case "long":
+    case "date":
+    case "bytes":
+    case "null":
+      return validatePrimitiveValue(value, rule);
+    case "object":
+      if (!(value instanceof CRDTObject)) {
+        return {
+          valid: false,
+          errors: [
+            {
+              path: rule.path,
+              message: `Expected object at path ${rule.path}`
+            }
+          ]
+        };
+      }
+      break;
+    case "array":
+      if (!(value instanceof CRDTArray)) {
+        return {
+          valid: false,
+          errors: [
+            {
+              path: rule.path,
+              message: `Expected array at path ${rule.path}`
+            }
+          ]
+        };
+      }
+      break;
+    case "yorkie.Text":
+      if (!(value instanceof CRDTText)) {
+        return {
+          valid: false,
+          errors: [
+            {
+              path: rule.path,
+              message: `Expected yorkie.Text at path ${rule.path}`
+            }
+          ]
+        };
+      }
+      break;
+    case "yorkie.Tree":
+      if (!(value instanceof CRDTTree)) {
+        return {
+          valid: false,
+          errors: [
+            {
+              path: rule.path,
+              message: `Expected yorkie.Tree at path ${rule.path}`
+            }
+          ]
+        };
+      }
+      break;
+    case "yorkie.Counter":
+      if (!(value instanceof CRDTCounter)) {
+        return {
+          valid: false,
+          errors: [
+            {
+              path: rule.path,
+              message: `Expected yorkie.Counter at path ${rule.path}`
+            }
+          ]
+        };
+      }
+      break;
+    default:
+      throw new Error(`Unknown rule type: ${rule.type}`);
+  }
+  return {
+    valid: true
+  };
+}
+function getPrimitiveType(type) {
+  switch (type) {
+    case "null":
+      return PrimitiveType.Null;
+    case "boolean":
+      return PrimitiveType.Boolean;
+    case "integer":
+      return PrimitiveType.Integer;
+    case "long":
+      return PrimitiveType.Long;
+    case "double":
+      return PrimitiveType.Double;
+    case "string":
+      return PrimitiveType.String;
+    case "bytes":
+      return PrimitiveType.Bytes;
+    case "date":
+      return PrimitiveType.Date;
+    default:
+      throw new Error(`Unknown primitive type: ${type}`);
+  }
+}
+function validatePrimitiveValue(value, rule) {
+  if (value instanceof Primitive && value.getType() === getPrimitiveType(rule.type)) {
+    return { valid: true };
+  }
+  return {
+    valid: false,
+    errors: [
+      {
+        path: rule.path,
+        message: `Expected ${rule.type} at path ${rule.path}`
+      }
+    ]
+  };
+}
 const Noop = () => {
 };
 class ObserverProxy {
@@ -19663,6 +20004,7 @@ class Document {
     __publicField(this, "checkpoint");
     __publicField(this, "localChanges");
     __publicField(this, "maxSizeLimit");
+    __publicField(this, "schemaRules");
     __publicField(this, "root");
     __publicField(this, "clone");
     __publicField(this, "eventStream");
@@ -19696,6 +20038,7 @@ class Document {
     this.checkpoint = InitialCheckpoint;
     this.localChanges = [];
     this.maxSizeLimit = 0;
+    this.schemaRules = [];
     this.eventStream = createObservable((observer) => {
       this.eventStreamObserver = observer;
     });
@@ -19715,7 +20058,7 @@ class Document {
    * `update` executes the given updater to update this document.
    */
   update(updater, message) {
-    var _a2;
+    var _a2, _b2, _c2;
     if (this.getStatus() === "removed") {
       throw new YorkieError(Code.ErrDocumentRemoved, `${this.key} is removed`);
     }
@@ -19746,7 +20089,21 @@ class Document {
     } finally {
       this.isUpdating = false;
     }
-    const size = totalDocSize((_a2 = this.clone) == null ? void 0 : _a2.root.getDocSize());
+    const schemaRules = this.getSchemaRules();
+    if (!context.isPresenceOnlyChange() && schemaRules.length > 0) {
+      const result = validateYorkieRuleset(
+        (_a2 = this.clone) == null ? void 0 : _a2.root.getObject(),
+        schemaRules
+      );
+      if (!result.valid) {
+        this.clone = void 0;
+        throw new YorkieError(
+          Code.ErrDocumentSchemaValidationFailed,
+          `schema validation failed: ${(_b2 = result.errors) == null ? void 0 : _b2.map((error) => error.message).join(", ")}`
+        );
+      }
+    }
+    const size = totalDocSize((_c2 = this.clone) == null ? void 0 : _c2.root.getDocSize());
     if (!context.isPresenceOnlyChange() && this.maxSizeLimit > 0 && this.maxSizeLimit < size) {
       this.clone = void 0;
       throw new YorkieError(
@@ -20194,6 +20551,18 @@ class Document {
   setMaxSizePerDocument(size) {
     this.maxSizeLimit = size;
   }
+  /**
+   * `getSchemaRules` gets the schema rules of this document.
+   */
+  getSchemaRules() {
+    return this.schemaRules;
+  }
+  /**
+   * `setSchemaRules` sets the schema rules of this document.
+   */
+  setSchemaRules(rules) {
+    this.schemaRules = rules;
+  }
   /**
    * `garbageCollect` purges elements that were removed before the given time.
    *
@@ -20895,7 +21264,7 @@ function createAuthInterceptor(apiKey, token) {
   };
 }
 const name = "@yorkie-js/sdk";
-const version = "0.6.17";
+const version = "0.6.20";
 const pkg = {
   name,
   version
@@ -21121,7 +21490,8 @@ class Client {
         const res = await this.rpcClient.attachDocument(
           {
             clientId: this.id,
-            changePack: converter.toChangePack(doc.createChangePack())
+            changePack: converter.toChangePack(doc.createChangePack()),
+            schemaKey: opts.schema
           },
           { headers: { "x-shard-key": `${this.apiKey}/${doc.getKey()}` } }
         );
@@ -21129,6 +21499,9 @@ class Client {
         if (maxSize > 0) {
           doc.setMaxSizePerDocument(res.maxSizePerDocument);
         }
+        if (res.schemaRules.length > 0) {
+          doc.setSchemaRules(converter.fromSchemaRules(res.schemaRules));
+        }
         const pack = converter.fromChangePack(res.changePack);
         doc.applyChangePack(pack);
         if (doc.getStatus() === DocStatus.Removed) {