@kairos-es/core 1.0.0-alpha.4 → 1.0.0-alpha.6

package/src/AppendIsOwned.ts

@@ -30,15 +30,15 @@
  *
  * ## Present means refused, so a sanctioned append REMOVES the marker
  *
- * The check reads the tag through `Effect.serviceOption`, so its ABSENCE is the
+ * The check reads the service through `Effect.serviceOption`, so its ABSENCE is the
  * normal case and costs the `append` signature nothing — `DcbEventStore.append`
  * keeps `R = never` and no caller provides anything. Presence is what refuses.
  *
  * That shape decides how the two legitimate appends inside a bracket get through,
  * and there is only one route: run with the marker STRIPPED from the context
- * (`Effect.mapInputContext` over `Context.omit(AppendIsOwned)`). The bracket's own
+ * (`Effect.updateContext` over `Context.omit(AppendIsOwned)`). The bracket's own
  * closing append is issued outside the scope it provided the marker in, and the
- * codec's escape hatch strips it explicitly. Neither needs a second tag, a
+ * codec's escape hatch strips it explicitly. Neither needs a second service, a
  * sanctioning flag or a mutable cell, and there is no way to be exempt by
  * accident: an append is either lexically outside the marked region or it says in
  * as many words that it is removing the marker.
@@ -50,13 +50,13 @@ import { Context, Effect } from 'effect'
  * owns it.
  *
  * `by` is a human-readable owner name and exists for the defect message alone —
- * the refusal is decided by the tag's PRESENCE, never by this value, so nothing
+ * the refusal is decided by the service's PRESENCE, never by this value, so nothing
  * branches on it and no caller need agree on a vocabulary for it.
  */
-export class AppendIsOwned extends Context.Tag('@kairos-es/core/AppendIsOwned')<
+export class AppendIsOwned extends Context.Service<
   AppendIsOwned,
   { readonly by: string }
->() {}
+>()('@kairos-es/core/AppendIsOwned') {}
 
 /**
  * Die if an append is already owned here; do nothing otherwise.
@@ -70,7 +70,7 @@ export class AppendIsOwned extends Context.Tag('@kairos-es/core/AppendIsOwned')<
  * its escape hatch for a deliberate second append — which is what makes a defect
  * affordable here.
  *
- * `Effect.serviceOption` is what keeps this free: it reads the tag if present and
+ * `Effect.serviceOption` is what keeps this free: it reads the service if present and
  * adds NOTHING to the requirement channel, so every existing append is unchanged
  * and unprovisioned.
  */

package/src/ContractStore.ts

@@ -8,7 +8,8 @@
  * channel (`never` for the pure in-memory engine; `SqlError` for either SQL one).
  * The decorator wraps those mechanics with the policy the contract demands — the
  * policy the first two engines hand-duplicated, with the Postgres one even
- * needing a bespoke `catchAll`/`instanceof`:
+ * needing a bespoke `catchAll`/`instanceof` (Effect 3's `catchAll`, which Effect 4
+ * names `catch`):
  *
  * - `assertServableQuery` at every verb's entry (read, the append condition's
  *   guard query, subscribe) — a non-servable query, or one carrying a key the
@@ -75,7 +76,7 @@ export interface RawDcbEventStore<E> {
  */
 export const makeContractStore = <E>(
   raw: RawDcbEventStore<E>,
-): DcbEventStore['Type'] => ({
+): DcbEventStore['Service'] => ({
   read: (query, options) =>
     Effect.suspend(() => {
       // Defects (surface when the Effect runs), keeping `read` at `E = never`.
@@ -90,7 +91,7 @@ export const makeContractStore = <E>(
   append: (events, condition) =>
     // The ownership refusal runs FIRST and sits OUTSIDE the suspend, because it is
     // the only one of append's checks that is EFFECTFUL: it consults a
-    // `Context.Tag` rather than inspecting the arguments. `Effect.flatMap` over an
+    // `Context.Service` rather than inspecting the arguments. `Effect.flatMap` over an
     // already-lazy effect defers it exactly as the suspend defers the throws below,
     // so nothing runs at the call site either way; what it buys is that the
     // "you are inside a bracket" defect arrives before any argument is judged, which
@@ -156,7 +157,7 @@ export const makeContractStore = <E>(
         // engine's channel simply answers false and dies as it should. It also
         // narrows the raw `AppendConditionFailed | E` to the contract's single
         // error, which is what keeps `append` at `E = AppendConditionFailed`.
-        return Effect.catchAll(raw.append(events, condition), (error) =>
+        return Effect.catch(raw.append(events, condition), (error) =>
           Predicate.isTagged('AppendConditionFailed')(error)
             ? Effect.fail(error)
             : Effect.die(error),

package/src/DcbEventStore.ts

@@ -1,5 +1,5 @@
 /**
- * The `DcbEventStore` contract: a `Context.Tag` with no bundled implementation.
+ * The `DcbEventStore` contract: a `Context.Service` with no bundled implementation.
  * Consumers supply a `Layer` (the in-memory one lives in this package; each SQL
  * engine is a package of its own — `@kairos-es/store-postgres` and
  * `@kairos-es/store-sqlite`).
@@ -42,7 +42,7 @@ export interface ReadResponse {
   readonly head: Position
 }
 
-export class DcbEventStore extends Context.Tag('@kairos-es/core/DcbEventStore')<
+export class DcbEventStore extends Context.Service<
   DcbEventStore,
   {
     /**
@@ -74,4 +74,4 @@ export class DcbEventStore extends Context.Tag('@kairos-es/core/DcbEventStore')<
       after?: Position,
     ) => Stream.Stream<SequencedEvent, never, Scope.Scope>
   }
->() {}
+>()('@kairos-es/core/DcbEventStore') {}

package/src/Event.ts

@@ -6,19 +6,55 @@
  * payloads into these bytes. Ordering is by `position` alone; `occurredAt` is
  * producer-supplied domain time and is informational only.
  */
-import { Schema } from 'effect'
+import {
+  BigInt as BigInt_,
+  Effect,
+  Option,
+  Schema,
+  SchemaIssue,
+  SchemaTransformation,
+} from 'effect'
 
 /**
  * A position in the single global event log: a branded, non-negative `bigint`.
  *
  * The log is 64-bit (`bigserial` in Postgres) and exceeds JS `number` safety at
  * 2^53, so positions are a `bigint`. They are compared, never arithmetic'd.
- * `Schema.BigInt` encodes to a decimal string (JSON-safe) and decodes to
+ * Encoded, a position is a decimal string (JSON-safe, `String(b)`); decoded, a
  * `bigint`. `0n` is the "before the first event" sentinel used by `after` and by
  * an empty store's head.
+ *
+ * The string-to-`bigint` step is hand-built rather than Effect 4's
+ * `Schema.BigIntFromString`, because that schema accepts only `^-?\d+$` and so
+ * refuses inputs the encoded side has always admitted — `" 5"`, `"+5"`,
+ * `"0x10"`. The decode here is the global `BigInt(s)` behind a blank-string
+ * refusal, which is `BigInt.fromString` and is exactly what Effect 3's
+ * `Schema.BigInt` ran, so a position string any earlier release decoded still
+ * decodes to the same value. The non-negative check then runs on the `bigint`,
+ * as it always did.
  */
-export const Position = Schema.BigInt.pipe(
-  Schema.nonNegativeBigInt(),
+export const Position = Schema.String.pipe(
+  Schema.decodeTo(
+    Schema.BigInt,
+    SchemaTransformation.transformEffect<bigint, string>({
+      decode: (s, options) =>
+        Option.match(BigInt_.fromString(s), {
+          onNone: () =>
+            Effect.fail(
+              new SchemaIssue.InvalidValue(
+                {
+                  message: `Unable to decode ${JSON.stringify(s)} into a bigint`,
+                },
+                s,
+                options,
+              ),
+            ),
+          onSome: Effect.succeed,
+        }),
+      encode: (b) => Effect.succeed(String(b)),
+    }),
+  ),
+  Schema.check(Schema.isGreaterThanOrEqualToBigInt(0n)),
   Schema.brand('Position'),
 )
 export type Position = typeof Position.Type
@@ -33,7 +69,7 @@ export const ORIGIN: Position = Position.make(0n)
  * item's tags (superset test).
  */
 export const Tag = Schema.String.pipe(
-  Schema.pattern(/^[^:]+:.+/, { identifier: 'Tag' }),
+  Schema.check(Schema.isPattern(/^[^:]+:.+/, { identifier: 'Tag' })),
   Schema.brand('Tag'),
 )
 export type Tag = typeof Tag.Type
@@ -95,7 +131,7 @@ export const tagIdentity = (key: string): TagIdentity => {
  * `ReadLimit.make(n)`.
  */
 export const ReadLimit = Schema.Int.pipe(
-  Schema.greaterThanOrEqualTo(0),
+  Schema.check(Schema.isGreaterThanOrEqualTo(0)),
   Schema.brand('ReadLimit'),
 )
 export type ReadLimit = typeof ReadLimit.Type
@@ -105,7 +141,7 @@ export type ReadLimit = typeof ReadLimit.Type
  * in the name (e.g. `course-registered.v2`); only non-emptiness is enforced.
  */
 export const EventType = Schema.String.pipe(
-  Schema.nonEmptyString(),
+  Schema.check(Schema.isNonEmpty()),
   Schema.brand('EventType'),
 )
 export type EventType = typeof EventType.Type
@@ -159,10 +195,7 @@ export type EventType = typeof EventType.Type
  * alone: it would make an event the store accepted unreadable for ever, so a
  * value check belongs at write or nowhere.
  */
-export const Metadata = Schema.Record({
-  key: Schema.String,
-  value: Schema.String,
-})
+export const Metadata = Schema.Record(Schema.String, Schema.String)
 export type Metadata = typeof Metadata.Type
 
 /**
@@ -172,6 +205,8 @@ export type Metadata = typeof Metadata.Type
  *
  * `data` is `Uint8Array` (opaque bytes); the store does not interpret it.
  * `uuid` is producer-supplied to keep `core` deterministic (no RNG in core).
+ * It is checked for UUID SHAPE only (`isGUID`), not for a version nibble: a
+ * stricter check would refuse ids an existing log already holds.
  * `occurredAt` is informational only; ordering is by position alone.
  * `metadata` mirrors `tags` rather than `data`: REQUIRED, with an empty bag
  * legal. Required because an absent-versus-empty divergence between engines is
@@ -181,10 +216,10 @@ export type Metadata = typeof Metadata.Type
  */
 export const DcbEvent = Schema.Struct({
   type: EventType,
-  data: Schema.Uint8ArrayFromSelf,
+  data: Schema.Uint8Array,
   tags: Schema.Array(Tag),
-  uuid: Schema.UUID,
-  occurredAt: Schema.DateTimeUtc,
+  uuid: Schema.String.check(Schema.isGUID()),
+  occurredAt: Schema.DateTimeUtcFromString,
   metadata: Metadata,
 })
 export type DcbEvent = typeof DcbEvent.Type

package/src/Query.ts

@@ -273,7 +273,7 @@ export const classifyServableQuery = (query: Query): ServableQueryShape => {
   }
   const only = query.items.length === 1 ? query.items[0] : undefined
   if (only !== undefined && only.tags.length === 0) {
-    return Arr.isNonEmptyReadonlyArray(only.types)
+    return Arr.isReadonlyArrayNonEmpty(only.types)
       ? { kind: 'typeOnly', types: only.types }
       : { kind: 'wildcard' }
   }