@helios-lang/effect 0.1.1 → 0.1.2

package/src/Uplc/DataSchema.test.ts

@@ -1,207 +0,0 @@
-import { describe, expect, it } from "bun:test"
-import { Schema } from "effect"
-import * as DataSchema from "./DataSchema.js"
-
-describe("Uplc.DataSchema.BigInt", () => {
-  it("succeeds for {int: 0n}", () => {
-    expect(Schema.decodeSync(DataSchema.BigInt)({ int: 0n })).toBe(0n)
-  })
-
-  it("fails for {int: '0'}", () => {
-    expect(() =>
-      Schema.decodeUnknownSync(DataSchema.BigInt)({ int: "0" })
-    ).toThrow()
-  })
-})
-
-describe("Uplc.DataSchema.Int", () => {
-  it("succeeds for {int: 0n}", () => {
-    expect(Schema.decodeSync(DataSchema.Int)({ int: 0n })).toBe(0)
-  })
-
-  it("fails for {int: '0'}", () => {
-    expect(() =>
-      Schema.decodeUnknownSync(DataSchema.Int)({ int: "0" })
-    ).toThrow()
-  })
-})
-
-describe("Uplc.DataSchema.String", () => {
-  it("succeeds for {bytes: ''}", () => {
-    expect(Schema.decodeSync(DataSchema.String)({ bytes: "" })).toBe("")
-  })
-
-  it("fails for {bytes: 'ff'}", () => {
-    expect(() =>
-      Schema.decodeSync(DataSchema.String)({ bytes: "ff" })
-    ).toThrow()
-  })
-
-  it("succeeds for {bytes: '48656C6C6F20576F726C64'}", () => {
-    expect(
-      Schema.decodeSync(DataSchema.String)({ bytes: "48656C6C6F20576F726C64" })
-    ).toBe("Hello World")
-  })
-})
-
-describe("Uplc.DataSchema.Array", () => {
-  it("succeeds for empty ListData", () => {
-    expect(
-      Schema.decodeSync(DataSchema.Array(DataSchema.String))({ list: [] })
-    ).toEqual([])
-  })
-
-  it("succeeds for ListData containg single 'Hello World' string", () => {
-    expect(
-      Schema.decodeSync(DataSchema.Array(DataSchema.String))({
-        list: [{ bytes: "48656C6C6F20576F726C64" }]
-      })
-    ).toEqual(["Hello World"])
-  })
-
-  it("fails if ListData items are heterogenous", () => {
-    expect(() =>
-      Schema.decodeSync(DataSchema.Array(DataSchema.String))({
-        list: [{ bytes: "48656C6C6F20576F726C64" }, { int: 0n }]
-      })
-    ).toThrow()
-  })
-})
-
-describe("Uplc.DataSchema.Struct", () => {
-  it("succeeds for empty ListData for empty Struct", () => {
-    expect(Schema.decodeSync(DataSchema.Struct({}))({ list: [] })).toEqual({})
-  })
-
-  it("fails for empty ListData if one field is defined", () => {
-    expect(() =>
-      Schema.decodeSync(DataSchema.Struct({ foo: DataSchema.String }))({
-        list: []
-      })
-    ).toThrow()
-  })
-
-  it("succeeds for ListData with single entry if one field is defined", () => {
-    expect(
-      Schema.decodeSync(DataSchema.Struct({ foo: DataSchema.String }))({
-        list: [{ bytes: "48656C6C6F20576F726C64" }]
-      })
-    ).toEqual({ foo: "Hello World" })
-  })
-
-  it("fails for ListData with wrong entry in first place with one field is defined", () => {
-    expect(() =>
-      Schema.decodeSync(DataSchema.Struct({ foo: DataSchema.String }))({
-        list: [{ int: 0n }]
-      })
-    ).toThrow()
-  })
-
-  it("succeeds for ListData with spurious entries at end with one field is defined", () => {
-    expect(
-      Schema.decodeSync(DataSchema.Struct({ foo: DataSchema.String }))({
-        list: [{ bytes: "48656C6C6F20576F726C64" }, { int: 0n }]
-      })
-    ).toEqual({ foo: "Hello World" })
-  })
-
-  it("succeeds for ListData with two entries with two fields", () => {
-    expect(
-      Schema.decodeSync(
-        DataSchema.Struct({ foo: DataSchema.String, bar: DataSchema.Int })
-      )({ list: [{ bytes: "48656C6C6F20576F726C64" }, { int: 0n }] })
-    ).toEqual({ foo: "Hello World", bar: 0 })
-  })
-
-  it("fails for ListData with two entries in wrong order with two fields", () => {
-    expect(() =>
-      Schema.decodeSync(
-        DataSchema.Struct({ bar: DataSchema.Int, foo: DataSchema.String })
-      )({ list: [{ bytes: "48656C6C6F20576F726C64" }, { int: 0n }] })
-    ).toThrow()
-  })
-})
-
-describe("Uplc.DataSchema.EnumVariant", () => {
-  it("succeeds for empty ConstrData for empty EnumVariant", () => {
-    expect(
-      Schema.decodeSync(DataSchema.EnumVariant(0, {}))({
-        constructor: 0,
-        fields: []
-      })
-    ).toEqual({})
-  })
-
-  it("fields for ConstrData with wrong tag", () => {
-    expect(() =>
-      Schema.decodeSync(DataSchema.EnumVariant(0, {}))({
-        constructor: 1,
-        fields: []
-      })
-    ).toThrow()
-  })
-
-  it("fails for empty ConstrData if one field is defined", () => {
-    expect(() =>
-      Schema.decodeSync(DataSchema.EnumVariant(0, { foo: DataSchema.String }))({
-        constructor: 0,
-        fields: []
-      })
-    ).toThrow()
-  })
-
-  it("succeeds for ConstrData with single entry if one field is defined", () => {
-    expect(
-      Schema.decodeSync(DataSchema.EnumVariant(0, { foo: DataSchema.String }))({
-        constructor: 0,
-        fields: [{ bytes: "48656C6C6F20576F726C64" }]
-      })
-    ).toEqual({ foo: "Hello World" })
-  })
-
-  it("fails for ConstrData with wrong entry in first place with one field is defined", () => {
-    expect(() =>
-      Schema.decodeSync(DataSchema.EnumVariant(0, { foo: DataSchema.String }))({
-        constructor: 0,
-        fields: [{ int: 0n }]
-      })
-    ).toThrow()
-  })
-
-  it("succeeds for EnumVariant with spurious entries at end with one field is defined", () => {
-    expect(
-      Schema.decodeSync(DataSchema.EnumVariant(0, { foo: DataSchema.String }))({
-        constructor: 0,
-        fields: [{ bytes: "48656C6C6F20576F726C64" }, { int: 0n }]
-      })
-    ).toEqual({ foo: "Hello World" })
-  })
-
-  it("succeeds for EnumVariant with two entries with two fields", () => {
-    expect(
-      Schema.decodeSync(
-        DataSchema.EnumVariant(0, {
-          foo: DataSchema.String,
-          bar: DataSchema.Int
-        })
-      )({
-        constructor: 0,
-        fields: [{ bytes: "48656C6C6F20576F726C64" }, { int: 0n }]
-      })
-    ).toEqual({ foo: "Hello World", bar: 0 })
-  })
-
-  it("fails for EnumVariant with two entries in wrong order with two fields", () => {
-    expect(() =>
-      Schema.decodeSync(
-        DataSchema.EnumVariant(0, {
-          bar: DataSchema.Int,
-          foo: DataSchema.String
-        })
-      )({
-        constructor: 0,
-        fields: [{ bytes: "48656C6C6F20576F726C64" }, { int: 0n }]
-      })
-    ).toThrow()
-  })
-})

package/src/Uplc/DataSchema.ts

@@ -1,181 +0,0 @@
-import { Effect, Encoding, ParseResult, Schema } from "effect"
-import { decode as decodeUtf8, encode as encodeUtf8 } from "../internal/Utf8.js"
-import { DataUnencoded as Data } from "./Data.js"
-
-const BigIntSchema = Schema.transformOrFail(Data, Schema.BigIntFromSelf, {
-  strict: true,
-  decode: (data) => {
-    if ("int" in data) {
-      return ParseResult.succeed(data.int)
-    } else {
-      return ParseResult.fail(
-        new ParseResult.Unexpected(data, "expected IntData")
-      )
-    }
-  },
-  encode: (value) => ParseResult.succeed({ int: value })
-})
-
-export { BigIntSchema as BigInt }
-
-export const Int = Schema.transformOrFail(Data, Schema.Int, {
-  strict: true,
-  decode: (data) => {
-    if ("int" in data) {
-      return ParseResult.succeed(Number(data.int))
-    } else {
-      return ParseResult.fail(
-        new ParseResult.Unexpected(data, "expected IntData")
-      )
-    }
-  },
-  encode: (value) => {
-    if (value % 1.0 != 0) {
-      return ParseResult.fail(
-        new ParseResult.Unexpected(value, "not an integer")
-      )
-    } else {
-      return ParseResult.succeed({ int: BigInt(Math.round(value)) })
-    }
-  }
-})
-
-export const ByteArray = Schema.transformOrFail(
-  Data,
-  Schema.Uint8ArrayFromHex,
-  {
-    strict: true,
-    decode: (data) => {
-      if ("bytes" in data) {
-        return ParseResult.succeed(data.bytes)
-      } else {
-        return ParseResult.fail(
-          new ParseResult.Unexpected(data, "expected ByteArrayData")
-        )
-      }
-    },
-    encode: (hex) => ParseResult.succeed({ bytes: hex })
-  }
-)
-
-const StringSchema = Schema.transformOrFail(Data, Schema.String, {
-  strict: true,
-  decode: (data) => {
-    if ("bytes" in data) {
-      return decodeUtf8(data.bytes).pipe(
-        Effect.mapError((e) => {
-          return new ParseResult.Unexpected(data.bytes, e.message)
-        })
-      )
-    } else {
-      return ParseResult.fail(
-        new ParseResult.Unexpected(data, "expected ByteArrayData")
-      )
-    }
-  },
-  encode: (s) =>
-    ParseResult.succeed({ bytes: Encoding.encodeHex(encodeUtf8(s)) })
-})
-
-export { StringSchema as String }
-
-const ArraySchema = <ItemType>(
-  itemSchema: Schema.Schema<ItemType, Schema.Schema.Encoded<typeof Data>>
-) =>
-  Schema.transformOrFail(Data, Schema.Array(itemSchema), {
-    strict: true,
-    decode: (data) => {
-      if ("list" in data) {
-        return ParseResult.succeed(data.list)
-      } else {
-        return ParseResult.fail(
-          new ParseResult.Unexpected(data, "expected ListData")
-        )
-      }
-    },
-    encode: (items) => ParseResult.succeed({ list: items })
-  })
-
-export { ArraySchema as Array }
-
-export const Struct = <
-  FieldTypes extends { [key: string]: any }
->(fieldSchemas: {
-  [FieldName in keyof FieldTypes]: Schema.Schema<FieldTypes[FieldName], Data>
-}) =>
-  Schema.transformOrFail(Data, Schema.Struct(fieldSchemas), {
-    strict: true,
-    decode: (data) => {
-      if ("list" in data) {
-        return Effect.all(
-          Object.entries(fieldSchemas).map(([fieldName], i) => {
-            if (i >= data.list.length) {
-              return Effect.fail(
-                new ParseResult.Unexpected(
-                  data,
-                  `expected at least ${i + 1} entries in ListData`
-                )
-              )
-            }
-
-            const itemData = data.list[i]
-
-            return Effect.succeed([fieldName, itemData] as [string, Data])
-          })
-        ).pipe(Effect.map(Object.fromEntries))
-      } else {
-        return ParseResult.fail(
-          new ParseResult.Unexpected(data, "expected ListData")
-        )
-      }
-    },
-    encode: (fields) => ParseResult.succeed({ list: Object.values(fields) })
-  })
-
-export const EnumVariant = <FieldTypes extends { [key: string]: any }>(
-  tag: number | bigint,
-  fieldSchemas: {
-    [FieldName in keyof FieldTypes]: Schema.Schema<FieldTypes[FieldName], Data>
-  }
-) =>
-  Schema.transformOrFail(Data, Schema.Struct(fieldSchemas), {
-    strict: true,
-    decode: (data) => {
-      if ("fields" in data) {
-        if (data.constructor != Number(tag)) {
-          return ParseResult.fail(
-            new ParseResult.Unexpected(
-              data,
-              `expected ConstrData with constructor tag ${tag}`
-            )
-          )
-        }
-
-        return Effect.all(
-          Object.entries(fieldSchemas).map(([fieldName], i) => {
-            if (i >= data.fields.length) {
-              return Effect.fail(
-                new ParseResult.Unexpected(
-                  data,
-                  `expected at least ${i + 1} entries in ConstrData`
-                )
-              )
-            }
-
-            const itemData = data.fields[i]
-            
-            return Effect.succeed([fieldName, itemData] as [string, Data])
-          })
-        ).pipe(Effect.map(Object.fromEntries))
-      } else {
-        return ParseResult.fail(
-          new ParseResult.Unexpected(data, "expected ConstrData")
-        )
-      }
-    },
-    encode: (fields) =>
-      ParseResult.succeed({
-        constructor: Number(tag),
-        fields: Object.values(fields)
-      })
-  })