@actyx/sdk/lib/v1/types.js

Actyx SDK

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ConnectivityStatus = exports.ConnectivityStatusType = exports.AllEventsSortOrder = exports.AllEventsSortOrders = exports.PersistedEventsSortOrder = exports.PersistedEventsSortOrders = exports.UnstoredEvents = exports.UnstoredEvent = exports.Events = exports.Event = exports._compareEvents = exports.EventIO = exports.OffsetMapWithDefault = exports.createEnumType = exports.EnumType = void 0;
/*
 * Actyx SDK: Functions for writing distributed apps
 * deployed on peer-to-peer networks, without any servers.
 *
 * Copyright (C) 2021 Actyx AG
 */
/*
 * Actyx Pond: A TypeScript framework for writing distributed apps
 * deployed on peer-to-peer networks, without any servers.
 *
 * Copyright (C) 2020 Actyx AG
 */
const Either_1 = require("fp-ts/lib/Either");
const string_1 = require("fp-ts/lib/string");
const number_1 = require("fp-ts/lib/number");
const t = require("io-ts");
const types_1 = require("../types");
// EnumType Class
class EnumType extends t.Type {
    constructor(e, name) {
        super(name || 'enum', (u) => Object.values(this.enumObject).some((v) => v === u), (u, c) => (this.is(u) ? t.success(u) : t.failure(u, c)), t.identity);
        this._tag = 'EnumType';
        this.enumObject = e;
    }
}
exports.EnumType = EnumType;
// simple helper function
const createEnumType = (e, name) => new EnumType(e, name);
exports.createEnumType = createEnumType;
/**
 * Basically adds -infinity and +infinity to a PSN
 */
const PsnOrLimit = t.union([t.number, t.literal('min'), t.literal('max')]);
/**
 * A psn map with a default value, so it is a tabulated total function from source to PsnOrLimit
 */
exports.OffsetMapWithDefault = t.readonly(t.type({
    psns: t.readonly(t.record(t.string, t.number)),
    default: PsnOrLimit,
}));
const stringRA = t.array(t.string);
const Tags = new t.Type('TagsSetFromArray', (x) => x instanceof Array && x.every(types_1.isString), 
// Rust side for now expresses empty tag arrays as omitting the field
(x, c) => (x === undefined ? (0, Either_1.right)([]) : stringRA.validate(x, c)), 
// Sending empty arrays is fine, though
(x) => x);
exports.EventIO = t.type({
    psn: t.number,
    semantics: t.string,
    sourceId: t.string,
    name: t.string,
    timestamp: t.number,
    lamport: t.number,
    tags: Tags,
    payload: t.unknown,
});
const _compareEvents = (a, b) => {
    const lamportOrder = number_1.Ord.compare(a.lamport, b.lamport);
    if (lamportOrder !== 0) {
        return lamportOrder;
    }
    const sourceOrder = string_1.Ord.compare(a.sourceId, b.sourceId);
    if (sourceOrder !== 0) {
        return sourceOrder;
    }
    return number_1.Ord.compare(a.psn, b.psn);
};
exports._compareEvents = _compareEvents;
const eventsEqual = (a, b) => 
// compare numerical fields first since it should be faster
a.lamport === b.lamport && a.psn === b.psn && a.sourceId === b.sourceId;
/**
 * Order for events
 *
 * Order is [lamport, sourceId]
 * Events are considered equal when lamport, sourceId, psn are equal without considering
 * the content of the payload. Having two events that have these fields equal yet a different
 * payload would be a grave bug in our system.
 */
const ordEvent = {
    equals: eventsEqual,
    compare: exports._compareEvents,
};
/** Event-related constants */
exports.Event = {
    ord: ordEvent,
};
/**
 * A number of events, not necessarily from the same source.
 */
exports.Events = t.array(exports.EventIO);
/**
 * A number of generated events, that are going to be written to the store.
 */
exports.UnstoredEvent = t.readonly(t.type({
    /**
     * the sequence nr of the first element in this chunk
     */
    semantics: t.string,
    name: t.string,
    timestamp: t.number,
    tags: Tags,
    payload: t.unknown,
}));
exports.UnstoredEvents = t.readonlyArray(exports.UnstoredEvent);
/**
 * Sort order for perstisted events
 */
var PersistedEventsSortOrders;
(function (PersistedEventsSortOrders) {
    PersistedEventsSortOrders["EventKey"] = "eventKey";
    PersistedEventsSortOrders["ReverseEventKey"] = "reverseEventKey";
    PersistedEventsSortOrders["Unsorted"] = "unsorted";
})(PersistedEventsSortOrders = exports.PersistedEventsSortOrders || (exports.PersistedEventsSortOrders = {}));
exports.PersistedEventsSortOrder = (0, exports.createEnumType)(PersistedEventsSortOrders, 'PersistedEventsSortOrders');
/**
 * Sort order for events
 */
var AllEventsSortOrders;
(function (AllEventsSortOrders) {
    AllEventsSortOrders["EventKey"] = "eventKey";
    AllEventsSortOrders["Unsorted"] = "unsorted";
})(AllEventsSortOrders = exports.AllEventsSortOrders || (exports.AllEventsSortOrders = {}));
exports.AllEventsSortOrder = (0, exports.createEnumType)(AllEventsSortOrders, 'AllEventsSortOrders');
/**
 * Connectivity status type.
 * @public
 */
var ConnectivityStatusType;
(function (ConnectivityStatusType) {
    ConnectivityStatusType["FullyConnected"] = "FullyConnected";
    ConnectivityStatusType["PartiallyConnected"] = "PartiallyConnected";
    ConnectivityStatusType["NotConnected"] = "NotConnected";
})(ConnectivityStatusType = exports.ConnectivityStatusType || (exports.ConnectivityStatusType = {}));
const FullyConnected = t.readonly(t.type({
    status: t.literal(ConnectivityStatusType.FullyConnected),
    inCurrentStatusForMs: t.number,
}));
const PartiallyConnected = t.readonly(t.type({
    status: t.literal(ConnectivityStatusType.PartiallyConnected),
    inCurrentStatusForMs: t.number,
    specialsDisconnected: t.readonlyArray(t.string),
    swarmConnectivityLevel: t.number,
    eventsToRead: t.number,
    eventsToSend: t.number,
}));
const NotConnected = t.readonly(t.type({
    status: t.literal(ConnectivityStatusType.NotConnected),
    inCurrentStatusForMs: t.number,
    eventsToRead: t.number,
    eventsToSend: t.number,
}));
/**
 * The IO-TS type parser for ConnectivityStatus.
 * @public
 */
exports.ConnectivityStatus = t.union([FullyConnected, PartiallyConnected, NotConnected]);
//# sourceMappingURL=types.js.map