@multiplatform.one/frappe 6.0.0

package/dist/cjs/core/wire.spec.cjs

@@ -0,0 +1,478 @@
+var import_vitest = require("vitest");
+var import_wire = require("./wire.cjs");
+(0, import_vitest.describe)("Wire Protocol Types", () => {
+  (0, import_vitest.describe)("DEFAULT_WIRE_ENDPOINTS", () => {
+    (0, import_vitest.it)("should have correct default endpoints", () => {
+      (0, import_vitest.expect)(import_wire.defaultWireEndpoints).toEqual({
+        create: "my_app.api.create_doc",
+        update: "my_app.api.update_doc",
+        delete: "my_app.api.delete_doc",
+        backfill: "my_app.api.backfill"
+      });
+    });
+    (0, import_vitest.it)("should have all required endpoints", () => {
+      (0, import_vitest.expect)(import_wire.defaultWireEndpoints).toHaveProperty("create");
+      (0, import_vitest.expect)(import_wire.defaultWireEndpoints).toHaveProperty("update");
+      (0, import_vitest.expect)(import_wire.defaultWireEndpoints).toHaveProperty("delete");
+      (0, import_vitest.expect)(import_wire.defaultWireEndpoints).toHaveProperty("backfill");
+      (0, import_vitest.expect)(Object.keys(import_wire.defaultWireEndpoints)).toHaveLength(4);
+    });
+  });
+  (0, import_vitest.describe)("Type Guards", () => {
+    (0, import_vitest.describe)("isConflictError", () => {
+      (0, import_vitest.it)("should return true for conflict error", () => {
+        const error = {
+          error: "VERSION_MISMATCH",
+          message: "Version conflict",
+          current_version: "v2"
+        };
+        (0, import_vitest.expect)((0, import_wire.isConflictError)(error)).toBe(true);
+      });
+      (0, import_vitest.it)("should return false for non-conflict error", () => {
+        (0, import_vitest.expect)((0, import_wire.isConflictError)({})).toBe(false);
+        (0, import_vitest.expect)((0, import_wire.isConflictError)({
+          error: "OTHER_ERROR"
+        })).toBe(false);
+        (0, import_vitest.expect)((0, import_wire.isConflictError)(null)).toBe(false);
+        (0, import_vitest.expect)((0, import_wire.isConflictError)(void 0)).toBe(false);
+      });
+      (0, import_vitest.it)("should handle partial conflict error", () => {
+        const error = {
+          error: "VERSION_MISMATCH"
+        };
+        (0, import_vitest.expect)((0, import_wire.isConflictError)(error)).toBe(true);
+      });
+    });
+    (0, import_vitest.describe)("isPreconditionFailedError", () => {
+      (0, import_vitest.it)("should return true for precondition failed error", () => {
+        const error = {
+          error: "PRECONDITION_FAILED",
+          message: "Precondition failed",
+          current_etag: "etag123"
+        };
+        (0, import_vitest.expect)((0, import_wire.isPreconditionFailedError)(error)).toBe(true);
+      });
+      (0, import_vitest.it)("should return false for non-precondition error", () => {
+        (0, import_vitest.expect)((0, import_wire.isPreconditionFailedError)({})).toBe(false);
+        (0, import_vitest.expect)((0, import_wire.isPreconditionFailedError)({
+          error: "OTHER"
+        })).toBe(false);
+        (0, import_vitest.expect)((0, import_wire.isPreconditionFailedError)(null)).toBe(false);
+      });
+    });
+    (0, import_vitest.describe)("isValidationError", () => {
+      (0, import_vitest.it)("should return true for validation error", () => {
+        const error = {
+          exc_type: "ValidationError",
+          exception: "Field required"
+        };
+        (0, import_vitest.expect)((0, import_wire.isValidationError)(error)).toBe(true);
+      });
+      (0, import_vitest.it)("should return false for non-validation error", () => {
+        (0, import_vitest.expect)((0, import_wire.isValidationError)({})).toBe(false);
+        (0, import_vitest.expect)((0, import_wire.isValidationError)({
+          exc_type: "OtherError"
+        })).toBe(false);
+        (0, import_vitest.expect)((0, import_wire.isValidationError)(null)).toBe(false);
+      });
+    });
+    (0, import_vitest.describe)("isPermissionError", () => {
+      (0, import_vitest.it)("should return true for permission error", () => {
+        const error = {
+          exc_type: "PermissionError",
+          exception: "Access denied"
+        };
+        (0, import_vitest.expect)((0, import_wire.isPermissionError)(error)).toBe(true);
+      });
+      (0, import_vitest.it)("should return false for non-permission error", () => {
+        (0, import_vitest.expect)((0, import_wire.isPermissionError)({})).toBe(false);
+        (0, import_vitest.expect)((0, import_wire.isPermissionError)({
+          exc_type: "OtherError"
+        })).toBe(false);
+        (0, import_vitest.expect)((0, import_wire.isPermissionError)(void 0)).toBe(false);
+      });
+    });
+    (0, import_vitest.describe)("isNotFoundError", () => {
+      (0, import_vitest.it)("should return true for not found error", () => {
+        const error = {
+          exc_type: "DoesNotExistError",
+          exception: "Document not found"
+        };
+        (0, import_vitest.expect)((0, import_wire.isNotFoundError)(error)).toBe(true);
+      });
+      (0, import_vitest.it)("should return false for non-not-found error", () => {
+        (0, import_vitest.expect)((0, import_wire.isNotFoundError)({})).toBe(false);
+        (0, import_vitest.expect)((0, import_wire.isNotFoundError)({
+          exc_type: "OtherError"
+        })).toBe(false);
+        (0, import_vitest.expect)((0, import_wire.isNotFoundError)(null)).toBe(false);
+      });
+    });
+    (0, import_vitest.describe)("multiple type guards", () => {
+      (0, import_vitest.it)("should correctly identify mixed error types", () => {
+        const conflictErr = {
+          error: "VERSION_MISMATCH",
+          message: "Conflict"
+        };
+        const validationErr = {
+          exc_type: "ValidationError",
+          exception: "Invalid"
+        };
+        (0, import_vitest.expect)((0, import_wire.isConflictError)(conflictErr)).toBe(true);
+        (0, import_vitest.expect)((0, import_wire.isValidationError)(conflictErr)).toBe(false);
+        (0, import_vitest.expect)((0, import_wire.isValidationError)(validationErr)).toBe(true);
+        (0, import_vitest.expect)((0, import_wire.isConflictError)(validationErr)).toBe(false);
+      });
+    });
+  });
+  (0, import_vitest.describe)("Request Body Types", () => {
+    (0, import_vitest.it)("should correctly type CreateRequestBody", () => {
+      const createBody = {
+        doctype: "TestDocType",
+        title: "Test Title",
+        status: "Active",
+        custom_field: "value"
+      };
+      (0, import_vitest.expect)(createBody.doctype).toBe("TestDocType");
+      (0, import_vitest.expect)(createBody.title).toBe("Test Title");
+    });
+    (0, import_vitest.it)("should correctly type UpdateRequestBody", () => {
+      const updateBody = {
+        doctype: "TestDocType",
+        name: "TEST-001",
+        values: {
+          title: "Updated Title",
+          status: "Completed"
+        }
+      };
+      (0, import_vitest.expect)(updateBody.doctype).toBe("TestDocType");
+      (0, import_vitest.expect)(updateBody.name).toBe("TEST-001");
+      (0, import_vitest.expect)(updateBody.values).toHaveProperty("title");
+    });
+    (0, import_vitest.it)("should correctly type DeleteRequestBody", () => {
+      const deleteBody = {
+        doctype: "TestDocType",
+        name: "TEST-001"
+      };
+      (0, import_vitest.expect)(deleteBody.doctype).toBe("TestDocType");
+      (0, import_vitest.expect)(deleteBody.name).toBe("TEST-001");
+    });
+    (0, import_vitest.it)("should correctly type ListSinceParams", () => {
+      const params = {
+        doctype: "TestDocType",
+        modified_after: "2025-01-01T00:00:00Z",
+        limit: 100,
+        fields: ["name", "title"],
+        filters: {
+          status: "Active"
+        }
+      };
+      (0, import_vitest.expect)(params.doctype).toBe("TestDocType");
+      (0, import_vitest.expect)(params.limit).toBe(100);
+      (0, import_vitest.expect)(params.fields).toContain("name");
+    });
+  });
+  (0, import_vitest.describe)("Response Types", () => {
+    (0, import_vitest.it)("should correctly type DocumentResponse", () => {
+      const doc = {
+        name: "TEST-001",
+        doctype: "TestDocType",
+        owner: "user@example.com",
+        creation: "2025-01-01T10:00:00Z",
+        modified: "2025-01-02T10:00:00Z",
+        modified_by: "admin@example.com",
+        docstatus: 0,
+        idx: 1,
+        custom_field: "value"
+      };
+      (0, import_vitest.expect)(doc.name).toBe("TEST-001");
+      (0, import_vitest.expect)(doc.docstatus).toBe(0);
+    });
+    (0, import_vitest.it)("should correctly type WireChildTableRow", () => {
+      const childRow = {
+        name: "CHILD-001",
+        idx: 1,
+        parent: "PARENT-001",
+        parenttype: "ParentDocType",
+        parentfield: "items",
+        item_name: "Test Item",
+        quantity: 5
+      };
+      (0, import_vitest.expect)(childRow.parent).toBe("PARENT-001");
+      (0, import_vitest.expect)(childRow.parentfield).toBe("items");
+    });
+    (0, import_vitest.it)("should correctly type CreateResponse", () => {
+      const response = {
+        name: "TEST-001",
+        doctype: "TestDocType",
+        owner: "user@example.com",
+        creation: "2025-01-01T10:00:00Z",
+        modified: "2025-01-01T10:00:00Z",
+        modified_by: "user@example.com",
+        docstatus: 0,
+        _idempotent_replay: false
+      };
+      (0, import_vitest.expect)(response._idempotent_replay).toBe(false);
+    });
+    (0, import_vitest.it)("should correctly type UpdateResponse", () => {
+      const response = {
+        name: "TEST-001",
+        doctype: "TestDocType",
+        owner: "user@example.com",
+        creation: "2025-01-01T10:00:00Z",
+        modified: "2025-01-02T10:00:00Z",
+        modified_by: "admin@example.com",
+        docstatus: 1,
+        _idempotent_replay: true
+      };
+      (0, import_vitest.expect)(response._idempotent_replay).toBe(true);
+      (0, import_vitest.expect)(response.docstatus).toBe(1);
+    });
+    (0, import_vitest.it)("should correctly type DeleteResponse", () => {
+      const response = {
+        message: "Document deleted successfully",
+        _idempotent_replay: false
+      };
+      (0, import_vitest.expect)(response.message).toBe("Document deleted successfully");
+      (0, import_vitest.expect)(response._idempotent_replay).toBe(false);
+    });
+    (0, import_vitest.it)("should correctly type ListSinceResponse", () => {
+      const response = {
+        rows: [{
+          name: "TEST-001",
+          doctype: "TestDocType",
+          owner: "user@example.com",
+          creation: "2025-01-01T10:00:00Z",
+          modified: "2025-01-01T10:00:00Z",
+          modified_by: "user@example.com",
+          docstatus: 0
+        }],
+        checkpoint: "checkpoint-123",
+        deleted: [{
+          doctype: "TestDocType",
+          name: "DELETED-001"
+        }]
+      };
+      (0, import_vitest.expect)(response.rows).toHaveLength(1);
+      (0, import_vitest.expect)(response.checkpoint).toBe("checkpoint-123");
+      (0, import_vitest.expect)(response.deleted).toHaveLength(1);
+    });
+  });
+  (0, import_vitest.describe)("Realtime Event Types", () => {
+    (0, import_vitest.it)("should correctly type DocChangedEvent", () => {
+      const event = {
+        event: "doc_changed",
+        message: {
+          doctype: "TestDocType",
+          name: "TEST-001"
+        }
+      };
+      (0, import_vitest.expect)(event.event).toBe("doc_changed");
+      (0, import_vitest.expect)(event.message.doctype).toBe("TestDocType");
+    });
+    (0, import_vitest.it)("should correctly type DocDeletedEvent", () => {
+      const event = {
+        event: "doc_deleted",
+        message: {
+          doctype: "TestDocType",
+          name: "TEST-001"
+        }
+      };
+      (0, import_vitest.expect)(event.event).toBe("doc_deleted");
+      (0, import_vitest.expect)(event.message.name).toBe("TEST-001");
+    });
+    (0, import_vitest.it)("should correctly type PermEpochBumpEvent", () => {
+      const event = {
+        event: "perm_epoch_bump",
+        message: {
+          epoch: 1234567890
+        }
+      };
+      (0, import_vitest.expect)(event.event).toBe("perm_epoch_bump");
+      (0, import_vitest.expect)(event.message.epoch).toBe(1234567890);
+    });
+    (0, import_vitest.it)("should correctly type ConnectEvent", () => {
+      const event = {
+        event: "connect",
+        sid: "session-id-123"
+      };
+      (0, import_vitest.expect)(event.event).toBe("connect");
+      (0, import_vitest.expect)(event.sid).toBe("session-id-123");
+    });
+    (0, import_vitest.it)("should correctly type DisconnectEvent", () => {
+      const event = {
+        event: "disconnect",
+        reason: "Client disconnected"
+      };
+      (0, import_vitest.expect)(event.event).toBe("disconnect");
+      (0, import_vitest.expect)(event.reason).toBe("Client disconnected");
+    });
+  });
+  (0, import_vitest.describe)("Wire Contract Types", () => {
+    (0, import_vitest.it)("should correctly type CreateWireContract", () => {
+      const contract = {
+        request: {
+          method: "POST",
+          endpoint: "/api/method/create",
+          headers: {
+            "Content-Type": "application/json",
+            "Idempotency-Key": "key-123"
+          },
+          body: {
+            doctype: "TestDocType",
+            title: "Test"
+          }
+        },
+        response: {
+          success: {
+            name: "TEST-001",
+            doctype: "TestDocType",
+            owner: "user@example.com",
+            creation: "2025-01-01T10:00:00Z",
+            modified: "2025-01-01T10:00:00Z",
+            modified_by: "user@example.com",
+            docstatus: 0
+          }
+        }
+      };
+      (0, import_vitest.expect)(contract.request.method).toBe("POST");
+      (0, import_vitest.expect)(contract.response.success.name).toBe("TEST-001");
+    });
+    (0, import_vitest.it)("should correctly type UpdateWireContract", () => {
+      const contract = {
+        request: {
+          method: "POST",
+          endpoint: "/api/method/update",
+          headers: {
+            "Content-Type": "application/json",
+            "If-Match": "etag-123"
+          },
+          body: {
+            doctype: "TestDocType",
+            name: "TEST-001",
+            values: {
+              title: "Updated"
+            }
+          }
+        },
+        response: {
+          success: {
+            name: "TEST-001",
+            doctype: "TestDocType",
+            owner: "user@example.com",
+            creation: "2025-01-01T10:00:00Z",
+            modified: "2025-01-02T10:00:00Z",
+            modified_by: "admin@example.com",
+            docstatus: 0
+          }
+        }
+      };
+      (0, import_vitest.expect)(contract.request.body.values.title).toBe("Updated");
+    });
+  });
+  (0, import_vitest.describe)("Utility Types", () => {
+    (0, import_vitest.it)("should extract success type from wire contract", () => {
+      const successData = {
+        data: "test"
+      };
+      (0, import_vitest.expect)(successData.data).toBe("test");
+    });
+    (0, import_vitest.it)("should handle WireEndpoints type", () => {
+      const customEndpoints = {
+        create: "custom.create",
+        update: "custom.update",
+        delete: "custom.delete",
+        backfill: "custom.backfill"
+      };
+      (0, import_vitest.expect)(customEndpoints.create).toBe("custom.create");
+      (0, import_vitest.expect)(customEndpoints.update).toBe("custom.update");
+    });
+    (0, import_vitest.it)("should handle MutationRequestHeaders type", () => {
+      const headers = {
+        "Content-Type": "application/json",
+        "Idempotency-Key": "key-123",
+        "If-Match": "etag-456",
+        "X-Frappe-CSRF-Token": "csrf-789",
+        Authorization: "Bearer token"
+      };
+      (0, import_vitest.expect)(headers["Content-Type"]).toBe("application/json");
+      (0, import_vitest.expect)(headers["Idempotency-Key"]).toBe("key-123");
+    });
+  });
+  (0, import_vitest.describe)("Error Response Types", () => {
+    (0, import_vitest.it)("should correctly type ConflictErrorResponse", () => {
+      const error = {
+        error: "VERSION_MISMATCH",
+        message: "Version conflict",
+        current_version: "v2",
+        current_doc: {
+          name: "TEST-001",
+          doctype: "TestDocType",
+          owner: "user@example.com",
+          creation: "2025-01-01T10:00:00Z",
+          modified: "2025-01-02T10:00:00Z",
+          modified_by: "admin@example.com",
+          docstatus: 0
+        }
+      };
+      (0, import_vitest.expect)(error.error).toBe("VERSION_MISMATCH");
+      (0, import_vitest.expect)(error.current_doc?.name).toBe("TEST-001");
+    });
+    (0, import_vitest.it)("should correctly type PreconditionFailedResponse", () => {
+      const error = {
+        error: "PRECONDITION_FAILED",
+        message: "ETag mismatch",
+        current_etag: "new-etag"
+      };
+      (0, import_vitest.expect)(error.error).toBe("PRECONDITION_FAILED");
+      (0, import_vitest.expect)(error.current_etag).toBe("new-etag");
+    });
+    (0, import_vitest.it)("should correctly type ValidationErrorResponse", () => {
+      const error = {
+        exc_type: "ValidationError",
+        exception: "Title is required",
+        _server_messages: "Validation failed"
+      };
+      (0, import_vitest.expect)(error.exc_type).toBe("ValidationError");
+      (0, import_vitest.expect)(error.exception).toBe("Title is required");
+    });
+    (0, import_vitest.it)("should correctly type PermissionErrorResponse", () => {
+      const error = {
+        exc_type: "PermissionError",
+        exception: "You don't have permission to access this document"
+      };
+      (0, import_vitest.expect)(error.exc_type).toBe("PermissionError");
+    });
+    (0, import_vitest.it)("should correctly type NotFoundErrorResponse", () => {
+      const error = {
+        exc_type: "DoesNotExistError",
+        exception: "Document TEST-001 not found"
+      };
+      (0, import_vitest.expect)(error.exc_type).toBe("DoesNotExistError");
+    });
+  });
+  (0, import_vitest.describe)("Docstatus Values", () => {
+    (0, import_vitest.it)("should only allow valid docstatus values", () => {
+      const draft = {
+        name: "TEST-001",
+        doctype: "TestDocType",
+        owner: "user@example.com",
+        creation: "2025-01-01T10:00:00Z",
+        modified: "2025-01-01T10:00:00Z",
+        modified_by: "user@example.com",
+        docstatus: 0
+      };
+      const submitted = {
+        ...draft,
+        docstatus: 1
+      };
+      const cancelled = {
+        ...draft,
+        docstatus: 2
+      };
+      (0, import_vitest.expect)(draft.docstatus).toBe(0);
+      (0, import_vitest.expect)(submitted.docstatus).toBe(1);
+      (0, import_vitest.expect)(cancelled.docstatus).toBe(2);
+    });
+  });
+});