@qlever-llc/trellis 0.7.0 → 0.8.0-rc.3

package/esm/npm/src/kv.js

@@ -0,0 +1,442 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _TypedKVEntry_value;
+import { Kvm } from "@nats-io/kv";
+import { jetstreamManager } from "@nats-io/jetstream";
+import { AsyncResult, Result } from "@qlever-llc/result";
+import Value, { ParseError } from "typebox/value";
+import { KVError, ValidationError } from "./errors/index.js";
+import { decodeSubject, escapeKvKey } from "./helpers.js";
+function externalizeValue(value) {
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (Array.isArray(value)) {
+        return value.map(externalizeValue);
+    }
+    if (value !== null && typeof value === "object") {
+        const out = {};
+        for (const [key, entry] of Object.entries(value)) {
+            if (entry !== undefined) {
+                out[key] = externalizeValue(entry);
+            }
+        }
+        return out;
+    }
+    return value;
+}
+function parseExternalValue(schema, value) {
+    if (Value.HasCodec(schema)) {
+        return Value.Decode(schema, value);
+    }
+    return Value.Parse(schema, value);
+}
+function serializeValue(schema, value) {
+    return JSON.stringify(Value.Parse(schema, externalizeValue(value)));
+}
+function serializeExternalValue(schema, value) {
+    return serializeValue(schema, value);
+}
+async function ensureExistingBucketOptions(nats, name, options) {
+    const desiredTtlMs = options.ttl ?? 0;
+    if (desiredTtlMs <= 0)
+        return;
+    const jsm = await jetstreamManager(nats);
+    const streamName = `KV_${name}`;
+    const info = await jsm.streams.info(streamName);
+    const desiredMaxAge = desiredTtlMs * 1_000_000;
+    if (info.config.max_age >= desiredMaxAge)
+        return;
+    await jsm.streams.update(info.config.name, {
+        ...info.config,
+        max_age: desiredMaxAge,
+    });
+}
+function isPlainObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function mergeUnknown(target, source) {
+    if (!isPlainObject(target) || !isPlainObject(source)) {
+        return source;
+    }
+    const out = { ...target };
+    for (const [key, entry] of Object.entries(source)) {
+        if (entry === undefined)
+            continue;
+        out[key] = mergeUnknown(target[key], entry);
+    }
+    return out;
+}
+function asRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function collectFailureText(value, depth = 0) {
+    if (depth > 2)
+        return "";
+    const parts = [];
+    if (value instanceof Error) {
+        parts.push(value.name, value.message);
+        if (value.cause !== undefined) {
+            parts.push(collectFailureText(value.cause, depth + 1));
+        }
+    }
+    if (typeof value === "string" || typeof value === "number") {
+        parts.push(String(value));
+    }
+    const record = asRecord(value);
+    if (record) {
+        for (const key of ["name", "message", "description", "code", "err_code"]) {
+            const field = record[key];
+            if (typeof field === "string" || typeof field === "number") {
+                parts.push(String(field));
+            }
+        }
+        if (record.api_error !== undefined) {
+            parts.push(collectFailureText(record.api_error, depth + 1));
+        }
+        if (record.cause !== undefined) {
+            parts.push(collectFailureText(record.cause, depth + 1));
+        }
+    }
+    return parts.join(" ").toLowerCase();
+}
+function inferKvFailureReason(operation, cause) {
+    const text = collectFailureText(cause);
+    if (text.includes("wrong last sequence") ||
+        text.includes("revision mismatch") ||
+        text.includes("sequence mismatch")) {
+        return operation === "create" ? "exists" : "revision mismatch";
+    }
+    if (operation === "create" &&
+        (text.includes("already exists") || text.includes("key exists"))) {
+        return "exists";
+    }
+    return undefined;
+}
+function kvError(operation, key, cause) {
+    const reason = inferKvFailureReason(operation, cause);
+    return new KVError({
+        operation,
+        cause,
+        context: reason === undefined ? { key } : { key, reason },
+    });
+}
+export class TypedKV {
+    constructor(schema, kv) {
+        Object.defineProperty(this, "schema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: schema
+        });
+        Object.defineProperty(this, "kv", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: kv
+        });
+    }
+    static fromParts(schema, kv) {
+        return new TypedKV(schema, kv);
+    }
+    static open(nats, name, schema, options) {
+        return AsyncResult.from((async () => {
+            try {
+                const kvm = new Kvm(nats);
+                const kv = options.bindOnly
+                    ? await kvm.open(name)
+                    : await kvm.create(name, {
+                        history: options.history ?? 1,
+                        ttl: options.ttl ?? 0,
+                        ...(options.replicas !== undefined
+                            ? { replicas: options.replicas }
+                            : {}),
+                        ...(options.maxValueBytes
+                            ? { maxValueSize: options.maxValueBytes }
+                            : {}),
+                    });
+                if (!options.bindOnly) {
+                    await ensureExistingBucketOptions(nats, name, options);
+                }
+                const typedKv = TypedKV.fromParts(schema, kv);
+                return Result.ok(typedKv);
+            }
+            catch (cause) {
+                return Result.err(new KVError({ operation: "open", cause }));
+            }
+        })());
+    }
+    get(key) {
+        return AsyncResult.from((async () => {
+            let s;
+            try {
+                s = await this.kv.get(escapeKvKey(key));
+            }
+            catch (cause) {
+                return Result.err(new KVError({ operation: "get", cause, context: { key } }));
+            }
+            if (!s) {
+                return Result.err(new KVError({
+                    operation: "get",
+                    context: { key, reason: "not found" },
+                }));
+            }
+            const result = await createTypedKvEntry(this.schema, this.kv, s);
+            return result;
+        })());
+    }
+    serialize(value) {
+        return serializeExternalValue(this.schema, value);
+    }
+    create(key, value) {
+        return AsyncResult.from((async () => {
+            try {
+                await this.kv.create(escapeKvKey(key), this.serialize(value));
+                return Result.ok(undefined);
+            }
+            catch (cause) {
+                return Result.err(kvError("create", key, cause));
+            }
+        })());
+    }
+    put(key, value) {
+        return AsyncResult.from((async () => {
+            try {
+                await this.kv.put(escapeKvKey(key), this.serialize(value));
+                return Result.ok(undefined);
+            }
+            catch (cause) {
+                return Result.err(kvError("put", key, cause));
+            }
+        })());
+    }
+    delete(key) {
+        return AsyncResult.from((async () => {
+            try {
+                await this.kv.delete(escapeKvKey(key));
+                return Result.ok(undefined);
+            }
+            catch (cause) {
+                return Result.err(kvError("delete", key, cause));
+            }
+        })());
+    }
+    keys(filter = ">") {
+        return AsyncResult.from((async () => {
+            try {
+                return Result.ok(await this.kv.keys(filter));
+            }
+            catch (cause) {
+                return Result.err(new KVError({ operation: "keys", cause, context: { filter } }));
+            }
+        })());
+    }
+    status() {
+        return AsyncResult.from((async () => {
+            try {
+                const status = await this.kv.status();
+                return Result.ok({ values: status.values });
+            }
+            catch (cause) {
+                return Result.err(new KVError({ operation: "status", cause }));
+            }
+        })());
+    }
+}
+export class TypedKVEntry {
+    constructor(schema, kv, entry, value) {
+        Object.defineProperty(this, "schema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: schema
+        });
+        Object.defineProperty(this, "kv", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: kv
+        });
+        Object.defineProperty(this, "entry", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: entry
+        });
+        _TypedKVEntry_value.set(this, void 0);
+        __classPrivateFieldSet(this, _TypedKVEntry_value, value, "f");
+    }
+    get value() {
+        return __classPrivateFieldGet(this, _TypedKVEntry_value, "f");
+    }
+    static create(schema, kv, entry) {
+        return AsyncResult.from((async () => {
+            const result = await createTypedKvEntry(schema, kv, entry);
+            return result;
+        })());
+    }
+    get key() {
+        return decodeSubject(this.entry.key);
+    }
+    get revision() {
+        return this.entry.revision;
+    }
+    get createdAt() {
+        return this.entry.created;
+    }
+    /**
+     * Watch this KV entry for changes.
+     *
+     * @param callback - Function called when the entry changes
+     * @param opts - Watch options (e.g., includeDeletes)
+     * @returns A function to stop watching
+     */
+    async watch(callback, opts) {
+        const watcher = await this.kv.watch({
+            key: this.entry.key,
+            include: opts?.includeDeletes ? "history" : "updates",
+        });
+        const abortController = new AbortController();
+        // Start the async iteration in the background
+        (async () => {
+            for await (const entry of watcher) {
+                if (abortController.signal.aborted)
+                    break;
+                if (entry.operation === "DEL" || entry.operation === "PURGE") {
+                    if (opts?.includeDeletes) {
+                        callback({
+                            type: "delete",
+                            key: decodeSubject(entry.key),
+                            revision: entry.revision,
+                            timestamp: entry.created,
+                        });
+                    }
+                }
+                else {
+                    try {
+                        const json = entry.json();
+                        const validated = parseExternalValue(this.schema, json);
+                        callback({
+                            type: "update",
+                            key: decodeSubject(entry.key),
+                            value: validated,
+                            revision: entry.revision,
+                            timestamp: entry.created,
+                        });
+                    }
+                    catch (cause) {
+                        callback({
+                            type: "error",
+                            key: decodeSubject(entry.key),
+                            error: createValidationError(this.schema, entry, cause),
+                            revision: entry.revision,
+                            timestamp: entry.created,
+                        });
+                    }
+                }
+            }
+        })();
+        return () => {
+            abortController.abort();
+            watcher.stop();
+        };
+    }
+    merge(value, vcc) {
+        const mergedData = mergeUnknown(__classPrivateFieldGet(this, _TypedKVEntry_value, "f"), value);
+        const mergeResult = Result.try(() => serializeExternalValue(this.schema, mergedData));
+        if (mergeResult.isErr()) {
+            const cause = mergeResult.error.cause;
+            if (cause instanceof ParseError) {
+                const errors = Value.Errors(this.schema, externalizeValue(mergedData));
+                return AsyncResult.err(new ValidationError({ errors, cause }));
+            }
+            return AsyncResult.err(new KVError({
+                operation: "merge",
+                cause: mergeResult.error,
+                context: { key: this.key },
+            }));
+        }
+        return this.put(mergedData, vcc);
+    }
+    put(value, vcc) {
+        return AsyncResult.from((async () => {
+            const serialized = serializeValue(this.schema, value);
+            try {
+                await this.kv.put(this.entry.key, serialized, {
+                    previousSeq: vcc ? this.entry.revision : undefined,
+                });
+                return Result.ok(undefined);
+            }
+            catch (cause) {
+                return Result.err(kvError("put", this.key, cause));
+            }
+        })());
+    }
+    delete(vcc) {
+        return AsyncResult.from((async () => {
+            try {
+                await this.kv.delete(this.entry.key, {
+                    previousSeq: vcc ? this.entry.revision : undefined,
+                });
+                return Result.ok(undefined);
+            }
+            catch (cause) {
+                return Result.err(kvError("delete", this.key, cause));
+            }
+        })());
+    }
+}
+_TypedKVEntry_value = new WeakMap();
+async function createTypedKvEntry(schema, kv, entry) {
+    const jsonResult = Result.try(() => entry.json());
+    if (jsonResult.isErr()) {
+        return Result.err(createValidationError(schema, entry, jsonResult.error));
+    }
+    const json = jsonResult.take();
+    const parseResult = Result.try(() => {
+        if (Value.HasCodec(schema)) {
+            return Value.Decode(schema, json);
+        }
+        return Value.Parse(schema, json);
+    });
+    if (parseResult.isErr()) {
+        return Result.err(createValidationError(schema, entry, parseResult.error, json));
+    }
+    const typedEntry = new TypedKVEntry(schema, kv, entry, parseResult.take());
+    return Result.ok(typedEntry);
+}
+function createValidationError(schema, entry, cause, json) {
+    if (cause instanceof ParseError) {
+        return new ValidationError({
+            errors: Value.Errors(schema, json),
+            cause,
+            context: {
+                key: decodeSubject(entry.key),
+                revision: entry.revision,
+            },
+        });
+    }
+    const error = cause instanceof Error ? cause : new Error(String(cause));
+    return new ValidationError({
+        errors: [{
+                path: "",
+                message: `Failed to decode KV value: ${error.message}`,
+            }],
+        cause: error,
+        context: {
+            key: decodeSubject(entry.key),
+            revision: entry.revision,
+        },
+    });
+}

package/esm/npm/src/models/auth/rpc/Logout.d.ts

@@ -0,0 +1,8 @@
+import Type, { type Static } from "typebox";
+export declare const AuthLogoutSchema: Type.TObject<{}>;
+export type AuthLogoutInput = Static<typeof AuthLogoutSchema>;
+export declare const AuthLogoutResponseSchema: Type.TObject<{
+    success: Type.TBoolean;
+}>;
+export type AuthLogoutResponse = Static<typeof AuthLogoutResponseSchema>;
+//# sourceMappingURL=Logout.d.ts.map

package/esm/npm/src/models/auth/rpc/Logout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Logout.d.ts","sourceRoot":"","sources":["../../../../../../src/models/auth/rpc/Logout.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,EAAE,EAAE,KAAK,MAAM,EAAE,MAAM,SAAS,CAAC;AAE5C,eAAO,MAAM,gBAAgB,kBAE5B,CAAC;AACF,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE9D,eAAO,MAAM,wBAAwB;;EAIpC,CAAC;AACF,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

package/esm/npm/src/models/auth/rpc/Logout.js

@@ -0,0 +1,5 @@
+import Type from "typebox";
+export const AuthLogoutSchema = Type.Object({});
+export const AuthLogoutResponseSchema = Type.Object({
+    success: Type.Boolean(),
+});

package/esm/npm/src/models/trellis/Paginate.d.ts

@@ -0,0 +1,7 @@
+import Type, { type StaticDecode } from "typebox";
+export declare const PaginateSchema: Type.TObject<{
+    offset: Type.TInteger;
+    limit: Type.TInteger;
+}>;
+export type Paginate = StaticDecode<typeof PaginateSchema>;
+//# sourceMappingURL=Paginate.d.ts.map

package/esm/npm/src/models/trellis/Paginate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Paginate.d.ts","sourceRoot":"","sources":["../../../../../src/models/trellis/Paginate.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,EAAE,EAAE,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAElD,eAAO,MAAM,cAAc;;;EAGzB,CAAC;AACH,MAAM,MAAM,QAAQ,GAAG,YAAY,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/esm/npm/src/models/trellis/Paginate.js

@@ -0,0 +1,5 @@
+import Type from "typebox";
+export const PaginateSchema = Type.Object({
+    offset: Type.Integer({ minimum: 0, default: 0 }),
+    limit: Type.Integer({ minimum: 0, default: 10 }),
+});

package/esm/npm/src/models/trellis/State.d.ts

@@ -0,0 +1,48 @@
+import Type, { type StaticDecode } from "typebox";
+import type { JsonValue as TrellisJsonValue } from "../../contracts.js";
+export declare const StateStoreKindSchema: Type.TUnion<[Type.TLiteral<"value">, Type.TLiteral<"map">]>;
+export type StateStoreKind = "value" | "map";
+export declare const StateScopeSchema: Type.TUnion<[Type.TLiteral<"userApp">, Type.TLiteral<"deviceApp">]>;
+export type StateScope = "userApp" | "deviceApp";
+export declare const JsonValueSchema: Type.TUnknown;
+export type JsonValue = TrellisJsonValue;
+export declare const StateEntrySchema: Type.TObject<{
+    key: Type.TOptional<Type.TString>;
+    value: Type.TUnknown;
+    revision: Type.TString;
+    updatedAt: Type.TString;
+    expiresAt: Type.TOptional<Type.TString>;
+}>;
+export type StateEntry = {
+    key?: string;
+    value: TrellisJsonValue;
+    revision: string;
+    updatedAt: string;
+    expiresAt?: string;
+};
+export declare const StateMigrationRequiredSchema: Type.TObject<{
+    migrationRequired: Type.TLiteral<true>;
+    entry: Type.TObject<{
+        key: Type.TOptional<Type.TString>;
+        value: Type.TUnknown;
+        revision: Type.TString;
+        updatedAt: Type.TString;
+        expiresAt: Type.TOptional<Type.TString>;
+    }>;
+    stateVersion: Type.TString;
+    currentStateVersion: Type.TString;
+    writerContractDigest: Type.TString;
+}>;
+export type StateMigrationRequired = {
+    migrationRequired: true;
+    entry: StateEntry;
+    stateVersion: string;
+    currentStateVersion: string;
+    writerContractDigest: string;
+};
+export declare const StateUserTargetSchema: Type.TObject<{
+    origin: Type.TString;
+    id: Type.TString;
+}>;
+export type StateUserTarget = StaticDecode<typeof StateUserTargetSchema>;
+//# sourceMappingURL=State.d.ts.map

package/esm/npm/src/models/trellis/State.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"State.d.ts","sourceRoot":"","sources":["../../../../../src/models/trellis/State.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,EAAE,EAAE,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAElD,OAAO,KAAK,EAAE,SAAS,IAAI,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAExE,eAAO,MAAM,oBAAoB,6DAG/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,KAAK,CAAC;AAE7C,eAAO,MAAM,gBAAgB,qEAG3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,WAAW,CAAC;AAEjD,eAAO,MAAM,eAAe,eAAiB,CAAC;AAC9C,MAAM,MAAM,SAAS,GAAG,gBAAgB,CAAC;AAEzC,eAAO,MAAM,gBAAgB;;;;;;EAM3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,gBAAgB,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;EAMvC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,iBAAiB,EAAE,IAAI,CAAC;IACxB,KAAK,EAAE,UAAU,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,oBAAoB,EAAE,MAAM,CAAC;CAC9B,CAAC;AAEF,eAAO,MAAM,qBAAqB;;;EAGhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,YAAY,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/esm/npm/src/models/trellis/State.js

@@ -0,0 +1,28 @@
+import Type from "typebox";
+export const StateStoreKindSchema = Type.Union([
+    Type.Literal("value"),
+    Type.Literal("map"),
+]);
+export const StateScopeSchema = Type.Union([
+    Type.Literal("userApp"),
+    Type.Literal("deviceApp"),
+]);
+export const JsonValueSchema = Type.Unknown();
+export const StateEntrySchema = Type.Object({
+    key: Type.Optional(Type.String({ minLength: 1 })),
+    value: JsonValueSchema,
+    revision: Type.String({ minLength: 1 }),
+    updatedAt: Type.String({ format: "date-time" }),
+    expiresAt: Type.Optional(Type.String({ format: "date-time" })),
+});
+export const StateMigrationRequiredSchema = Type.Object({
+    migrationRequired: Type.Literal(true),
+    entry: StateEntrySchema,
+    stateVersion: Type.String({ minLength: 1 }),
+    currentStateVersion: Type.String({ minLength: 1 }),
+    writerContractDigest: Type.String({ minLength: 1 }),
+});
+export const StateUserTargetSchema = Type.Object({
+    origin: Type.String({ minLength: 1 }),
+    id: Type.String({ minLength: 1 }),
+});

package/esm/npm/src/models/trellis/TrellisError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TrellisError.d.ts","sourceRoot":"","sources":["../../../../../src/models/trellis/TrellisError.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,EAAE,EAAE,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAElD;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;;;;;;EAMD,CAAC;AAEnC;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,YAAY,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/esm/npm/src/models/trellis/TrellisError.js

@@ -0,0 +1,15 @@
+import Type from "typebox";
+/**
+ * Open transport schema for Trellis RPC error payloads.
+ *
+ * Error payloads must always carry the base error fields, but service-local contract
+ * errors may add arbitrary additional properties. The client validates declared local
+ * errors against their contract schema before reconstructing runtime `Error` instances.
+ */
+export const TrellisErrorDataSchema = Type.Object({
+    id: Type.String(),
+    type: Type.String(),
+    message: Type.String(),
+    context: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+    traceId: Type.Optional(Type.String()),
+}, { additionalProperties: true });

package/esm/npm/src/models/trellis/rpc/StateDelete.d.ts

@@ -0,0 +1,12 @@
+import Type, { type Static } from "typebox";
+export declare const StateDeleteSchema: Type.TObject<{
+    store: Type.TString;
+    key: Type.TOptional<Type.TString>;
+    expectedRevision: Type.TOptional<Type.TString>;
+}>;
+export type StateDeleteInput = Static<typeof StateDeleteSchema>;
+export declare const StateDeleteResponseSchema: Type.TObject<{
+    deleted: Type.TBoolean;
+}>;
+export type StateDeleteResponse = Static<typeof StateDeleteResponseSchema>;
+//# sourceMappingURL=StateDelete.d.ts.map

package/esm/npm/src/models/trellis/rpc/StateDelete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StateDelete.d.ts","sourceRoot":"","sources":["../../../../../../src/models/trellis/rpc/StateDelete.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,EAAE,EAAE,KAAK,MAAM,EAAE,MAAM,SAAS,CAAC;AAE5C,eAAO,MAAM,iBAAiB;;;;EAI5B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAEhE,eAAO,MAAM,yBAAyB;;EAEpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC,OAAO,yBAAyB,CAAC,CAAC"}

package/esm/npm/src/models/trellis/rpc/StateDelete.js

@@ -0,0 +1,9 @@
+import Type from "typebox";
+export const StateDeleteSchema = Type.Object({
+    store: Type.String({ minLength: 1 }),
+    key: Type.Optional(Type.String({ minLength: 1 })),
+    expectedRevision: Type.Optional(Type.String({ minLength: 1 })),
+});
+export const StateDeleteResponseSchema = Type.Object({
+    deleted: Type.Boolean(),
+});

package/esm/npm/src/models/trellis/rpc/StateGet.d.ts

@@ -0,0 +1,38 @@
+import Type, { type Static } from "typebox";
+import type { StateEntry, StateMigrationRequired } from "../State.js";
+export declare const StateGetSchema: Type.TObject<{
+    store: Type.TString;
+    key: Type.TOptional<Type.TString>;
+}>;
+export type StateGetInput = Static<typeof StateGetSchema>;
+export declare const StateGetResponseSchema: Type.TUnion<[Type.TObject<{
+    found: Type.TLiteral<false>;
+}>, Type.TObject<{
+    found: Type.TLiteral<true>;
+    entry: Type.TObject<{
+        key: Type.TOptional<Type.TString>;
+        value: Type.TUnknown;
+        revision: Type.TString;
+        updatedAt: Type.TString;
+        expiresAt: Type.TOptional<Type.TString>;
+    }>;
+}>, Type.TObject<{
+    migrationRequired: Type.TLiteral<true>;
+    entry: Type.TObject<{
+        key: Type.TOptional<Type.TString>;
+        value: Type.TUnknown;
+        revision: Type.TString;
+        updatedAt: Type.TString;
+        expiresAt: Type.TOptional<Type.TString>;
+    }>;
+    stateVersion: Type.TString;
+    currentStateVersion: Type.TString;
+    writerContractDigest: Type.TString;
+}>]>;
+export type StateGetResponse = {
+    found: false;
+} | {
+    found: true;
+    entry: StateEntry;
+} | StateMigrationRequired;
+//# sourceMappingURL=StateGet.d.ts.map

package/esm/npm/src/models/trellis/rpc/StateGet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StateGet.d.ts","sourceRoot":"","sources":["../../../../../../src/models/trellis/rpc/StateGet.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,EAAE,EAAE,KAAK,MAAM,EAAE,MAAM,SAAS,CAAC;AAE5C,OAAO,KAAK,EAAE,UAAU,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAGtE,eAAO,MAAM,cAAc;;;EAGzB,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,OAAO,cAAc,CAAC,CAAC;AAE1D,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;IASjC,CAAC;AACH,MAAM,MAAM,gBAAgB,GACxB;IAAE,KAAK,EAAE,KAAK,CAAA;CAAE,GAChB;IAAE,KAAK,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,UAAU,CAAA;CAAE,GAClC,sBAAsB,CAAC"}

package/esm/npm/src/models/trellis/rpc/StateGet.js

@@ -0,0 +1,16 @@
+import Type from "typebox";
+import { StateEntrySchema, StateMigrationRequiredSchema } from "../State.js";
+export const StateGetSchema = Type.Object({
+    store: Type.String({ minLength: 1 }),
+    key: Type.Optional(Type.String({ minLength: 1 })),
+});
+export const StateGetResponseSchema = Type.Union([
+    Type.Object({
+        found: Type.Literal(false),
+    }),
+    Type.Object({
+        found: Type.Literal(true),
+        entry: StateEntrySchema,
+    }),
+    StateMigrationRequiredSchema,
+]);