@reifydb/core 0.0.1-alpha.1 → 0.0.1-alpha.10

package/dist/index.js

@@ -223,13 +223,13 @@ var BlobValue = class _BlobValue {
   }
 };
 
-// src/value/bool.ts
-var BoolValue = class _BoolValue {
+// src/value/boolean.ts
+var BooleanValue = class _BooleanValue {
   constructor(value) {
-    this.type = "Bool";
+    this.type = "Boolean";
     if (value !== void 0) {
       if (typeof value !== "boolean") {
-        throw new Error(`Bool value must be a boolean, got ${typeof value}`);
+        throw new Error(`Boolean value must be a boolean, got ${typeof value}`);
       }
       this.value = value;
     } else {
@@ -239,15 +239,15 @@ var BoolValue = class _BoolValue {
   static parse(str) {
     const trimmed = str.trim().toLowerCase();
     if (trimmed === "" || trimmed === UNDEFINED_VALUE) {
-      return new _BoolValue(void 0);
+      return new _BooleanValue(void 0);
     }
     if (trimmed === "true") {
-      return new _BoolValue(true);
+      return new _BooleanValue(true);
     }
     if (trimmed === "false") {
-      return new _BoolValue(false);
+      return new _BooleanValue(false);
     }
-    throw new Error(`Cannot parse "${str}" as Bool`);
+    throw new Error(`Cannot parse "${str}" as Boolean`);
   }
   valueOf() {
     return this.value;
@@ -262,8 +262,8 @@ var BoolValue = class _BoolValue {
     if (other.type !== this.type) {
       return false;
     }
-    const otherBool = other;
-    return this.value === otherBool.value;
+    const otherBoolean = other;
+    return this.value === otherBoolean.value;
   }
   encode() {
     return {
@@ -1051,6 +1051,46 @@ var DateTimeValue = class _DateTimeValue {
   }
 };
 
+// src/value/decimal.ts
+var DecimalValue = class _DecimalValue {
+  constructor(value) {
+    this.type = "Decimal";
+    if (value !== void 0) {
+      if (typeof value !== "string") {
+        throw new Error(`Decimal value must be a string, got ${typeof value}`);
+      }
+      this.value = value;
+    } else {
+      this.value = void 0;
+    }
+  }
+  static parse(str) {
+    if (str === UNDEFINED_VALUE) {
+      return new _DecimalValue(void 0);
+    }
+    return new _DecimalValue(str);
+  }
+  valueOf() {
+    return this.value;
+  }
+  toString() {
+    return this.value === void 0 ? "undefined" : this.value;
+  }
+  equals(other) {
+    if (other.type !== this.type) {
+      return false;
+    }
+    const otherDecimal = other;
+    return this.value === otherDecimal.value;
+  }
+  encode() {
+    return {
+      type: this.type,
+      value: this.value === void 0 ? UNDEFINED_VALUE : this.toString()
+    };
+  }
+};
+
 // src/value/float4.ts
 var _Float4Value = class _Float4Value {
   constructor(value) {
@@ -1450,16 +1490,16 @@ _Int16Value.MIN_VALUE = BigInt("-170141183460469231731687303715884105728");
 _Int16Value.MAX_VALUE = BigInt("170141183460469231731687303715884105727");
 var Int16Value = _Int16Value;
 
-// src/value/interval.ts
-var IntervalValue = class _IntervalValue {
+// src/value/duration.ts
+var DurationValue = class _DurationValue {
   // all time components as nanoseconds
   constructor(value) {
-    this.type = "Interval";
+    this.type = "Duration";
     if (value !== void 0) {
       if (typeof value === "string") {
-        const parsed = _IntervalValue.parseDuration(value);
+        const parsed = _DurationValue.parseDuration(value);
         if (!parsed) {
-          throw new Error(`Invalid interval string: ${value}`);
+          throw new Error(`Invalid duration string: ${value}`);
         }
         this.months = parsed.months;
         this.days = parsed.days;
@@ -1469,7 +1509,7 @@ var IntervalValue = class _IntervalValue {
         this.days = value.days;
         this.nanos = value.nanos;
       } else {
-        throw new Error(`Interval value must be an object or string, got ${typeof value}`);
+        throw new Error(`Duration value must be an object or string, got ${typeof value}`);
       }
     } else {
       this.months = void 0;
@@ -1478,96 +1518,96 @@ var IntervalValue = class _IntervalValue {
     }
   }
   /**
-   * Create a new interval from months, days, and nanoseconds
+   * Create a new duration from months, days, and nanoseconds
    */
   static new(months, days, nanos) {
-    return new _IntervalValue({ months, days, nanos });
+    return new _DurationValue({ months, days, nanos });
   }
   /**
-   * Create an interval from seconds
+   * Create a duration from seconds
    */
   static fromSeconds(seconds) {
-    return new _IntervalValue({ months: 0, days: 0, nanos: BigInt(seconds) * 1000000000n });
+    return new _DurationValue({ months: 0, days: 0, nanos: BigInt(seconds) * 1000000000n });
   }
   /**
-   * Create an interval from milliseconds
+   * Create a duration from milliseconds
    */
   static fromMilliseconds(milliseconds) {
-    return new _IntervalValue({ months: 0, days: 0, nanos: BigInt(milliseconds) * 1000000n });
+    return new _DurationValue({ months: 0, days: 0, nanos: BigInt(milliseconds) * 1000000n });
   }
   /**
-   * Create an interval from microseconds
+   * Create a duration from microseconds
    */
   static fromMicroseconds(microseconds) {
-    return new _IntervalValue({ months: 0, days: 0, nanos: BigInt(microseconds) * 1000n });
+    return new _DurationValue({ months: 0, days: 0, nanos: BigInt(microseconds) * 1000n });
   }
   /**
-   * Create an interval from nanoseconds
+   * Create a duration from nanoseconds
    */
   static fromNanoseconds(nanoseconds) {
-    return new _IntervalValue({ months: 0, days: 0, nanos: nanoseconds });
+    return new _DurationValue({ months: 0, days: 0, nanos: nanoseconds });
   }
   /**
-   * Create an interval from minutes
+   * Create a duration from minutes
    */
   static fromMinutes(minutes) {
-    return new _IntervalValue({ months: 0, days: 0, nanos: BigInt(minutes) * 60n * 1000000000n });
+    return new _DurationValue({ months: 0, days: 0, nanos: BigInt(minutes) * 60n * 1000000000n });
   }
   /**
-   * Create an interval from hours
+   * Create a duration from hours
    */
   static fromHours(hours) {
-    return new _IntervalValue({ months: 0, days: 0, nanos: BigInt(hours) * 60n * 60n * 1000000000n });
+    return new _DurationValue({ months: 0, days: 0, nanos: BigInt(hours) * 60n * 60n * 1000000000n });
   }
   /**
-   * Create an interval from days
+   * Create a duration from days
    */
   static fromDays(days) {
-    return new _IntervalValue({ months: 0, days, nanos: 0n });
+    return new _DurationValue({ months: 0, days, nanos: 0n });
   }
   /**
-   * Create an interval from weeks
+   * Create a duration from weeks
    */
   static fromWeeks(weeks) {
-    return new _IntervalValue({ months: 0, days: weeks * 7, nanos: 0n });
+    return new _DurationValue({ months: 0, days: weeks * 7, nanos: 0n });
   }
   /**
-   * Create an interval from months
+   * Create a duration from months
    */
   static fromMonths(months) {
-    return new _IntervalValue({ months, days: 0, nanos: 0n });
+    return new _DurationValue({ months, days: 0, nanos: 0n });
   }
   /**
-   * Create an interval from years
+   * Create a duration from years
    */
   static fromYears(years) {
-    return new _IntervalValue({ months: years * 12, days: 0, nanos: 0n });
+    return new _DurationValue({ months: years * 12, days: 0, nanos: 0n });
   }
   /**
-   * Create a zero interval
+   * Create a zero duration
    */
   static zero() {
-    return new _IntervalValue({ months: 0, days: 0, nanos: 0n });
+    return new _DurationValue({ months: 0, days: 0, nanos: 0n });
   }
   /**
-   * Get default interval (zero)
+   * Get default duration (zero)
    */
   static default() {
-    return _IntervalValue.zero();
+    return _DurationValue.zero();
   }
   /**
-   * Parse an interval string in ISO 8601 duration format
+   * Parse a duration string in ISO 8601 duration format
    */
   static parse(str) {
     const trimmed = str.trim();
     if (trimmed === "" || trimmed === UNDEFINED_VALUE) {
-      return new _IntervalValue(void 0);
+      return new _DurationValue(void 0);
     }
-    const parsed = _IntervalValue.parseDuration(trimmed);
+    const parsed = _DurationValue.parseDuration(trimmed);
     if (!parsed) {
-      throw new Error(`Cannot parse "${str}" as Interval`);
+      throw new Error(`Cannot parse "${str}" as Duration`);
     }
-    return new _IntervalValue({ months: parsed.months, days: parsed.days, nanos: parsed.nanos });
+    return new _DurationValue({ months: parsed.months, days: parsed.days, nanos: parsed.nanos });
   }
   /**
    * Get total seconds (truncated)
@@ -1615,7 +1655,7 @@ var IntervalValue = class _IntervalValue {
     return this.nanos;
   }
   /**
-   * Check if interval is positive (any component > 0)
+   * Check if duration is positive (any component > 0)
    */
   isPositive() {
     if (this.months === void 0 || this.days === void 0 || this.nanos === void 0) {
@@ -1624,7 +1664,7 @@ var IntervalValue = class _IntervalValue {
     return this.months > 0 || this.days > 0 || this.nanos > 0n;
   }
   /**
-   * Check if interval is negative (any component < 0)
+   * Check if duration is negative (any component < 0)
    */
   isNegative() {
     if (this.months === void 0 || this.days === void 0 || this.nanos === void 0) {
@@ -1633,26 +1673,26 @@ var IntervalValue = class _IntervalValue {
     return this.months < 0 || this.days < 0 || this.nanos < 0n;
   }
   /**
-   * Get absolute value of interval
+   * Get absolute value of duration
    */
   abs() {
     if (this.months === void 0 || this.days === void 0 || this.nanos === void 0) {
-      return new _IntervalValue(void 0);
+      return new _DurationValue(void 0);
     }
-    return new _IntervalValue({
+    return new _DurationValue({
       months: Math.abs(this.months),
       days: Math.abs(this.days),
       nanos: this.nanos < 0n ? -this.nanos : this.nanos
     });
   }
   /**
-   * Negate the interval
+   * Negate the duration
    */
   negate() {
     if (this.months === void 0 || this.days === void 0 || this.nanos === void 0) {
-      return new _IntervalValue(void 0);
+      return new _DurationValue(void 0);
     }
-    return new _IntervalValue({
+    return new _DurationValue({
       months: -this.months,
       days: -this.days,
       nanos: -this.nanos
@@ -1767,17 +1807,17 @@ var IntervalValue = class _IntervalValue {
     }
   }
   /**
-   * Compare two intervals for equality
+   * Compare two durations for equality
    */
   equals(other) {
     if (other.type !== this.type) {
       return false;
     }
-    const otherInterval = other;
-    if (this.months === void 0 || otherInterval.months === void 0) {
-      return this.months === otherInterval.months && this.days === otherInterval.days && this.nanos === otherInterval.nanos;
+    const otherDuration = other;
+    if (this.months === void 0 || otherDuration.months === void 0) {
+      return this.months === otherDuration.months && this.days === otherDuration.days && this.nanos === otherDuration.nanos;
     }
-    return this.months === otherInterval.months && this.days === otherInterval.days && this.nanos === otherInterval.nanos;
+    return this.months === otherDuration.months && this.days === otherDuration.days && this.nanos === otherDuration.nanos;
   }
   encode() {
     return {
@@ -2651,12 +2691,14 @@ function decode(pair) {
   switch (pair.type) {
     case "Blob":
       return BlobValue.parse(pair.value);
-    case "Bool":
-      return BoolValue.parse(pair.value);
+    case "Boolean":
+      return BooleanValue.parse(pair.value);
     case "Date":
       return DateValue.parse(pair.value);
     case "DateTime":
       return DateTimeValue.parse(pair.value);
+    case "Decimal":
+      return DecimalValue.parse(pair.value);
     case "Float4":
       return Float4Value.parse(pair.value);
     case "Float8":
@@ -2671,8 +2713,8 @@ function decode(pair) {
       return Int8Value.parse(pair.value);
     case "Int16":
       return Int16Value.parse(pair.value);
-    case "Interval":
-      return IntervalValue.parse(pair.value);
+    case "Duration":
+      return DurationValue.parse(pair.value);
     case "RowNumber":
       return RowNumberValue.parse(pair.value);
     case "Time":
@@ -2708,10 +2750,13 @@ var SchemaBuilder = class {
     return { kind: "primitive", type: "Blob" };
   }
   static bool() {
-    return { kind: "primitive", type: "Bool" };
+    return { kind: "primitive", type: "Boolean" };
   }
   static boolean() {
-    return { kind: "primitive", type: "Bool" };
+    return { kind: "primitive", type: "Boolean" };
+  }
+  static decimal() {
+    return { kind: "primitive", type: "Decimal" };
   }
   static float4() {
     return { kind: "primitive", type: "Float4" };
@@ -2776,8 +2821,8 @@ var SchemaBuilder = class {
   static time() {
     return { kind: "primitive", type: "Time" };
   }
-  static interval() {
-    return { kind: "primitive", type: "Interval" };
+  static duration() {
+    return { kind: "primitive", type: "Duration" };
   }
   static uuid4() {
     return { kind: "primitive", type: "Uuid4" };
@@ -2809,8 +2854,11 @@ var SchemaBuilder = class {
   static number() {
     return { kind: "primitive", type: "Float8" };
   }
-  static boolValue() {
-    return { kind: "value", type: "Bool" };
+  static booleanValue() {
+    return { kind: "value", type: "Boolean" };
+  }
+  static decimalValue() {
+    return { kind: "value", type: "Decimal" };
   }
   static int1Value() {
     return { kind: "value", type: "Int1" };
@@ -2860,8 +2908,8 @@ var SchemaBuilder = class {
   static timeValue() {
     return { kind: "value", type: "Time" };
   }
-  static intervalValue() {
-    return { kind: "value", type: "Interval" };
+  static durationValue() {
+    return { kind: "value", type: "Duration" };
   }
   static uuid4Value() {
     return { kind: "value", type: "Uuid4" };
@@ -2889,8 +2937,8 @@ function createValueInstance(type, value) {
   switch (type) {
     case "Blob":
       return new BlobValue(value);
-    case "Bool":
-      return new BoolValue(value);
+    case "Boolean":
+      return new BooleanValue(value);
     case "Float4":
       return new Float4Value(value);
     case "Float8":
@@ -2923,8 +2971,8 @@ function createValueInstance(type, value) {
       return new DateTimeValue(value);
     case "Time":
       return new TimeValue(value);
-    case "Interval":
-      return new IntervalValue(value);
+    case "Duration":
+      return new DurationValue(value);
     case "Uuid4":
       return new Uuid4Value(value);
     case "Uuid7":
@@ -2977,7 +3025,7 @@ function validateSchema(schema, value) {
       return schemaType === "Undefined";
     }
     switch (schemaType) {
-      case "Bool":
+      case "Boolean":
         return typeof value === "boolean";
       case "Float4":
       case "Float8":
@@ -2996,7 +3044,7 @@ function validateSchema(schema, value) {
         return typeof value === "number" && value >= 0;
       case "Utf8":
       case "Time":
-      case "Interval":
+      case "Duration":
       case "Uuid4":
       case "Uuid7":
       case "RowNumber":
@@ -3048,7 +3096,7 @@ var ReifyError = class extends Error {
     this.code = diagnostic.code;
     this.statement = diagnostic.statement;
     this.column = diagnostic.column;
-    this.span = diagnostic.span;
+    this.fragment = diagnostic.fragment;
     this.label = diagnostic.label;
     this.help = diagnostic.help;
     this.notes = diagnostic.notes ?? [];
@@ -3056,7 +3104,7 @@ var ReifyError = class extends Error {
     Object.setPrototypeOf(this, new.target.prototype);
   }
   toString() {
-    const position = this.span ? `line ${this.span.line}, offset ${this.span.offset}` : "unknown position";
+    const position = this.fragment ? `line ${this.fragment.line}, offset ${this.fragment.column}` : "unknown position";
     const notes = this.notes.length ? `
 Notes:
 - ${this.notes.join("\n- ")}` : "";
@@ -3071,9 +3119,11 @@ function asFrameResults(results) {
 }
 export {
   BlobValue,
-  BoolValue,
+  BooleanValue,
   DateTimeValue,
   DateValue,
+  DecimalValue,
+  DurationValue,
   Float4Value,
   Float8Value,
   IdentityIdValue,
@@ -3082,7 +3132,6 @@ export {
   Int2Value,
   Int4Value,
   Int8Value,
-  IntervalValue,
   ReifyError,
   RowNumberValue,
   Schema,