@certik/skynet 0.21.0 → 0.22.1

package/dist/indexer.js

@@ -0,0 +1,492 @@
+import meow from "meow";
+import { createRecord, getRecordByKey } from "./dynamodb";
+import { getEnvironment } from "./env";
+import { exponentialRetry } from "./availability";
+import { range as numberRange, fillRange as fillNumberRange } from "./util";
+import { getSelectorDesc, getSelectorFlags, toSelectorString } from "./selector";
+import { getBinaryName } from "./cli";
+import { inline } from "./log";
+import { findDateAfter, dateRange, daysInRange as fillDateRange } from "./date";
+const STATE_TABLE_NAME = "skynet-" + getEnvironment() + "-indexer-state";
+async function getIndexerLatestId(name, selectorFlags) {
+    const record = await getRecordByKey(STATE_TABLE_NAME, {
+        name: `${name}Since(${toSelectorString(selectorFlags)})`,
+    });
+    return record?.value;
+}
+async function getIndexerValidatedId(name, selectorFlags) {
+    const record = await getRecordByKey(STATE_TABLE_NAME, {
+        name: `${name}Validate(${toSelectorString(selectorFlags)})`,
+    });
+    if (record) {
+        return record.value;
+    }
+    return undefined;
+}
+function increaseId(type, currentId, n) {
+    if (type === "date") {
+        if (typeof currentId !== "string") {
+            throw new Error("invalid type for date id");
+        }
+        return findDateAfter(currentId, n);
+    }
+    if (typeof currentId !== "number") {
+        throw new Error("Invalid type for numeric id");
+    }
+    return (currentId + n);
+}
+// for those indexers that can have progress tracked by a numeric state.type
+// such as block height, or timestamp
+// managing state would be helpful to reduce the build time
+// and avoid unnecessary computation & storage
+function createModeIndexerApp({ binaryName, name, selector = {}, build, 
+// number of items run in a batch, determines the { from, to } to the build function
+buildBatchSize = 1, 
+// number of build functions calling at a time
+buildConcurrency = 1, 
+// commit updates every rolling window = buildBatchSize * buildConcurrency
+validate, 
+// number of items run in a batch, determines the { from, to } to the validate function
+validateBatchSize = 1, 
+// number of validate functions calling at a time
+validateConcurrency = 1, 
+// commit updates every rolling window = validateBatchSize * validateConcurrency
+maxRetry = 2, state, }) {
+    const defaultState = {
+        type: "block",
+        getMinId: async () => 1,
+        getMaxId: async () => {
+            throw new Error("must implement getMaxId");
+        },
+    };
+    const finalState = {
+        ...defaultState,
+        ...state,
+    };
+    // type based range functions
+    function range(from, to, step) {
+        if (typeof from === "string" && typeof to === "string") {
+            if (finalState.type === "date") {
+                return dateRange(from, to, step);
+            }
+            throw new Error("Invalid type for numeric range");
+        }
+        if (typeof from === "number" && typeof to === "number") {
+            return numberRange(from, to, step);
+        }
+        throw new Error("Invalid type for range");
+    }
+    function fillRange(from, to) {
+        if (typeof from === "string" && typeof to === "string") {
+            if (finalState.type === "date") {
+                return fillDateRange(from, to);
+            }
+            throw new Error("Invalid type for numeric range");
+        }
+        if (typeof from === "number" && typeof to === "number") {
+            return fillNumberRange(from, to);
+        }
+        throw new Error("Invalid type for range");
+    }
+    function offsetRange(from, to) {
+        return fillRange(from, to).length;
+    }
+    async function runMode(flags) {
+        const { mode, from: fromUntyped, to: toUntyped, status, verbose: verboseUntyped, ...untypeSelectorFlags } = flags;
+        const from = fromUntyped;
+        const to = toUntyped;
+        const verbose = verboseUntyped;
+        const selectorFlags = untypeSelectorFlags;
+        if (status) {
+            const stateItem = await getRecordByKey(STATE_TABLE_NAME, {
+                name: `${name}RebuildState(${toSelectorString(selectorFlags)})`,
+            });
+            const fromItem = await getRecordByKey(STATE_TABLE_NAME, {
+                name: `${name}Since(${toSelectorString(selectorFlags)})`,
+            });
+            const validateItem = await getRecordByKey(STATE_TABLE_NAME, {
+                name: `${name}Validate(${toSelectorString(selectorFlags)})`,
+            });
+            inline.log(`RebuildState=${stateItem?.value} Since=${fromItem?.value} Validated=${validateItem?.value}`);
+            process.exit(0);
+        }
+        inline.log(`[MODE INDEXER] mode=${mode}, env=${getEnvironment()}, ${toSelectorString(selectorFlags, ", ")}`);
+        if (mode === "reset") {
+            await runReset(selectorFlags);
+        }
+        else if (mode === "rebuild") {
+            const rebuildFrom = from || (await finalState.getMinId(selectorFlags));
+            const rebuildTo = to || (await finalState.getMaxId(selectorFlags));
+            await runReset(selectorFlags);
+            await runRebuild(selectorFlags, rebuildFrom, rebuildTo, verbose);
+        }
+        else if (mode === "resume-rebuild") {
+            const previousRebuildEnds = await getIndexerLatestId(name, selectorFlags);
+            const rebuildFrom = from ||
+                (previousRebuildEnds !== undefined && increaseId(finalState.type, previousRebuildEnds, 1)) ||
+                (await finalState.getMinId(selectorFlags));
+            const rebuildTo = to || (await finalState.getMaxId(selectorFlags));
+            await runRebuild(selectorFlags, rebuildFrom, rebuildTo, verbose);
+        }
+        else if (mode === "validate" || mode === "validation") {
+            const previousRebuildEnds = await getIndexerLatestId(name, selectorFlags);
+            if (!previousRebuildEnds) {
+                inline.log(`[MODE INDEXER] cannot validate without a successful rebuild`);
+                process.exit(0);
+            }
+            const previousValidatedTo = await getIndexerValidatedId(name, selectorFlags);
+            const validateFrom = from || previousValidatedTo || (await finalState.getMinId(selectorFlags));
+            const validateTo = to || previousRebuildEnds;
+            const shouldSaveState = !to; // should not save state for manual validations, those are for testing
+            await runValidate(selectorFlags, validateFrom, validateTo, shouldSaveState, verbose);
+        }
+        else if (mode === "one") {
+            if (to) {
+                inline.log("[MODE INDEXER] one mode ignores --to option. you may want to use range mode instead");
+            }
+            if (!from) {
+                inline.log(`[MODE INDEXER] must provide --from option for one mode`);
+                process.exit(1);
+            }
+            await runRange(selectorFlags, from, from, verbose);
+        }
+        else if (mode === "range") {
+            if (!from || !to) {
+                inline.log(`[MODE INDEXER] must provide --from and --to option for range mode`);
+                process.exit(1);
+            }
+            await runRange(selectorFlags, from, to, verbose);
+        }
+        else {
+            const stateItem = await getRecordByKey(STATE_TABLE_NAME, {
+                name: `${name}RebuildState(${toSelectorString(selectorFlags)})`,
+            });
+            // only build when rebuild succeed
+            if (!stateItem || stateItem.value !== "succeed") {
+                inline.log("[MODE INDEXER] skip because rebuild hasn't done yet");
+                process.exit(0);
+            }
+            const latestId = await getIndexerLatestId(name, selectorFlags);
+            if (!latestId) {
+                throw new Error(`[MODE INDEXER] cannot find the latest ${finalState.type}`);
+            }
+            const deltaFrom = increaseId(finalState.type, latestId, 1);
+            const deltaTo = await state.getMaxId(selectorFlags);
+            await runDelta(selectorFlags, deltaFrom, deltaTo, verbose);
+        }
+    }
+    async function runRange(selectorFlags, from, to, verbose) {
+        const startTime = Date.now();
+        inline.log(`[MODE INDEXER] building range, from=${from}, to=${to}, ${toSelectorString(selectorFlags, ", ")}, batchSize=${buildBatchSize}, concurrency=${buildConcurrency}`);
+        const failedIds = await execBuild(selectorFlags, from, to, verbose, false);
+        if (failedIds.length > 0) {
+            inline.log(`[MODE INDEXER] built with some failed ${finalState.type}`, failedIds);
+            process.exit(1);
+        }
+        else {
+            inline.log(`[MODE INDEXER] built successfully in ${Date.now() - startTime}ms`);
+            process.exit(0);
+        }
+    }
+    async function runValidate(selectorFlags, from, to, shouldSaveState, verbose) {
+        if (!validate) {
+            inline.log(`[MODE INDEXER] the indexer doesn't support validate mode, validate function not implemented`);
+            process.exit(1);
+        }
+        const startTime = Date.now();
+        inline.log(`[MODE INDEXER] validating, from=${from}, to=${to}, ${toSelectorString(selectorFlags, ", ")}, batchSize=${validateBatchSize}, concurrency=${validateConcurrency}`);
+        const windows = range(from, to, validateBatchSize * validateConcurrency);
+        inline.log(`[MODE INDEXER] from=${from}, to=${to}, batchSize=${validateBatchSize}, concurrency=${validateConcurrency}`);
+        for (const [windowStart, windowEnd] of windows) {
+            inline.log(`[MODE INDEXER] validating window ${windowStart}~${windowEnd}, concurrency=${validateConcurrency}`);
+            const batches = range(windowStart, windowEnd, validateBatchSize);
+            // add a retry for errors
+            await Promise.all(batches.map(async ([batchStart, batchEnd]) => {
+                const result = await exponentialRetry(async () => {
+                    try {
+                        await validate({
+                            ...selectorFlags,
+                            from: batchStart,
+                            to: batchEnd,
+                            verbose,
+                        });
+                        return true;
+                    }
+                    catch (err) {
+                        inline.error(`got error in validation`, err);
+                        return false;
+                    }
+                }, {
+                    maxRetry,
+                    test: (r) => r,
+                    verbose,
+                });
+                if (!result) {
+                    throw new Error(`Terminate validation due to critical errors, from=${batchStart}, to=${batchEnd}`);
+                }
+            }));
+            if (shouldSaveState) {
+                await createRecord(STATE_TABLE_NAME, {
+                    name: `${name}Validate(${toSelectorString(selectorFlags)})`,
+                    value: to,
+                });
+                if (verbose) {
+                    inline.log(`[MODE INDEXER] updated processed ${finalState.type} to ${windowEnd}`);
+                }
+            }
+        }
+        inline.log(`[MODE INDEXER] validated ${offsetRange(from, to)} ${finalState.type} successfully in ${Date.now() - startTime}ms`);
+    }
+    async function execBuild(selectorFlags, from, to, verbose, shouldSaveState = false) {
+        let failedIds = [];
+        const windows = range(from, to, buildBatchSize * buildConcurrency);
+        for (const [windowStart, windowEnd] of windows) {
+            inline.log(`[MODE INDEXER] building window ${windowStart}~${windowEnd}, concurrency = ${buildConcurrency}`);
+            const batches = range(windowStart, windowEnd, buildBatchSize);
+            // add a retry for errors
+            const batchResults = await Promise.all(batches.map(async ([batchStart, batchEnd]) => await exponentialRetry(async () => {
+                try {
+                    const ids = await build({
+                        ...selectorFlags,
+                        from: batchStart,
+                        to: batchEnd,
+                        verbose,
+                    });
+                    if (ids && ids.length > 0) {
+                        return ids;
+                    }
+                    else {
+                        return false;
+                    }
+                }
+                catch (err) {
+                    inline.error(`[MODE INDEXER] got error in build`, err);
+                    return fillRange(batchStart, batchEnd);
+                }
+            }, {
+                maxRetry,
+                test: (r) => !r,
+                verbose,
+            })));
+            if (shouldSaveState) {
+                await createRecord(STATE_TABLE_NAME, {
+                    name: `${name}Since(${toSelectorString(selectorFlags)})`,
+                    value: windowEnd,
+                });
+                if (verbose) {
+                    inline.log(`[MODE INDEXER] updated processed ${finalState.type} to ${windowEnd}`);
+                }
+            }
+            batchResults.forEach((ids) => {
+                if (ids) {
+                    failedIds = failedIds.concat(ids);
+                }
+            });
+        }
+        failedIds.sort();
+        return failedIds;
+    }
+    async function runRebuild(selectorFlags, from, to, verbose) {
+        const startTime = Date.now();
+        inline.log(`[MODE INDEXER] rebuilding, from=${from}, to=${to}, ${toSelectorString(selectorFlags, ", ")}, batchSize=${buildBatchSize}, concurrency=${buildConcurrency}`);
+        // add a flag to stop delta from running
+        await createRecord(STATE_TABLE_NAME, {
+            name: `${name}RebuildState(${toSelectorString(selectorFlags)})`,
+            value: "running",
+        });
+        const failedIds = await execBuild(selectorFlags, from, to, verbose, true);
+        // even if some transactions are failed we should continue to allow delta job running
+        // because rebuild is usally heavy
+        await createRecord(STATE_TABLE_NAME, {
+            name: `${name}Since(${toSelectorString(selectorFlags)})`,
+            value: to,
+        });
+        await createRecord(STATE_TABLE_NAME, {
+            name: `${name}RebuildState(${toSelectorString(selectorFlags)})`,
+            value: "succeed",
+        });
+        if (failedIds.length > 0) {
+            inline.log(`[MODE INDEXER] built ${offsetRange(from, to)} ${finalState.type}(s) with some failed ${finalState.type}`, failedIds);
+            process.exit(1);
+        }
+        else {
+            inline.log(`[MODE INDEXER] built ${offsetRange(from, to)} ${finalState.type}(s) successfully in ${Date.now() - startTime}ms`);
+            process.exit(0);
+        }
+    }
+    async function runDelta(selectorFlags, from, to, verbose) {
+        const startTime = Date.now();
+        if (to < from) {
+            inline.log(`[MODE INDEXER] skip delta, there're no more items need to be processed, from=${from}, to=${to}, ${toSelectorString(selectorFlags, ", ")}`);
+            return;
+        }
+        inline.log(`[MODE INDEXER] starting delta, from=${from}, to=${to}, ${toSelectorString(selectorFlags, ", ")}, batchSize=${buildBatchSize}, concurrency=${buildConcurrency}`);
+        try {
+            const failedIds = await execBuild(selectorFlags, from, to, verbose, true);
+            if (failedIds.length > 0) {
+                inline.log("[MODE INDEXER] built with some failed txs", failedIds);
+                await createRecord(STATE_TABLE_NAME, {
+                    name: `${name}DeltaState(${toSelectorString(selectorFlags)})`,
+                    value: "failed",
+                });
+                await createRecord(STATE_TABLE_NAME, {
+                    name: `${name}Since(${toSelectorString(selectorFlags)})`,
+                    value: to < failedIds[0] ? to : failedIds[0],
+                });
+                process.exit(1);
+            }
+            else {
+                await createRecord(STATE_TABLE_NAME, {
+                    name: `${name}DeltaState(${toSelectorString(selectorFlags)})`,
+                    value: "succeed",
+                });
+                await createRecord(STATE_TABLE_NAME, {
+                    name: `${name}Since(${toSelectorString(selectorFlags)})`,
+                    value: to,
+                });
+                inline.log(`[MODE INDEXER] built successfully in ${Date.now() - startTime}ms`);
+                process.exit(0);
+            }
+        }
+        catch (err) {
+            inline.error("[MODE INDEXER] delta build failed", from, to, err);
+            process.exit(1);
+        }
+    }
+    async function runReset(selectorFlags) {
+        const startTime = Date.now();
+        inline.log(`[MODE INDEXER] starting reset, ${toSelectorString(selectorFlags, ", ")}`);
+        inline.log("[MODE INDEXER] reset state", STATE_TABLE_NAME);
+        await createRecord(STATE_TABLE_NAME, {
+            name: `${name}Since(${toSelectorString(selectorFlags)})`,
+            value: 0,
+        });
+        await createRecord(STATE_TABLE_NAME, {
+            name: `${name}Validate(${toSelectorString(selectorFlags)})`,
+            value: 0,
+        });
+        await createRecord(STATE_TABLE_NAME, {
+            name: `${name}RebuildState(${toSelectorString(selectorFlags)})`,
+            value: "init",
+        });
+        inline.log(`[MODE INDEXER] reset successfully in ${Date.now() - startTime}ms`);
+    }
+    async function run() {
+        if (!binaryName) {
+            binaryName = getBinaryName();
+        }
+        const cli = meow(`
+        Usage
+
+          $ ${binaryName} <options>
+
+        Options
+${selector ? getSelectorDesc(selector) : ""}
+          --mode          could be delta/rebuild/resume-rebuild/validate/one/range/reset
+          --from          min ${finalState.type} to build
+          --to            max ${finalState.type} to build
+          --status        print status of indexer and exit
+          --verbose       Output debug messages
+      `, {
+            importMeta: import.meta,
+            description: false,
+            version: false,
+            flags: {
+                ...getSelectorFlags(selector),
+                mode: {
+                    type: "string",
+                    default: "delta",
+                },
+                from: {
+                    aliases: ["since"],
+                    type: "string",
+                },
+                to: {
+                    aliases: ["until"],
+                    type: "string",
+                },
+                status: {
+                    type: "boolean",
+                    default: false,
+                },
+                verbose: {
+                    type: "boolean",
+                    default: false,
+                },
+            },
+        });
+        try {
+            return runMode(cli.flags);
+        }
+        catch (err) {
+            inline.error(err);
+            process.exit(1);
+        }
+    }
+    return { run };
+}
+// for indexers that don't rely on a cursor
+// e.g. should always rebuild everything from scratch
+// or that the state can be easily inferred from existing data
+function createIndexerApp({ binaryName, selector = {}, build, maxRetry = 2, }) {
+    async function run() {
+        if (!binaryName) {
+            binaryName = getBinaryName();
+        }
+        const cli = meow(`
+        Usage
+          $ ${binaryName} <options>
+
+        Options
+${selector ? getSelectorDesc(selector) : ""}
+          --verbose       Output debug messages
+      `, {
+            importMeta: import.meta,
+            description: false,
+            version: false,
+            flags: {
+                ...getSelectorFlags(selector),
+                verbose: {
+                    type: "boolean",
+                    default: false,
+                },
+            },
+        });
+        async function runBuild(flags) {
+            const { verbose: untypedVerbose, ...untypedSelectorFlags } = flags;
+            const verbose = untypedVerbose;
+            const selectorFlags = untypedSelectorFlags;
+            const startTime = Date.now();
+            if (Object.keys(selectorFlags).length > 0) {
+                inline.log(`[INDEXER] starting build, ${toSelectorString(selectorFlags, ", ")}`);
+            }
+            else {
+                inline.log(`[INDEXER] starting build`);
+            }
+            const result = await exponentialRetry(async () => {
+                try {
+                    await build(flags);
+                    return true;
+                }
+                catch (err) {
+                    inline.log(`[INDEXER] got error in build`, err);
+                    return false;
+                }
+            }, {
+                maxRetry,
+                test: (r) => r,
+                verbose: verbose,
+            });
+            if (!result) {
+                throw new Error(`[INDEXER] Build failed due to critical errors`);
+            }
+            inline.log(`[INDEXER] build successfully in ${Date.now() - startTime}ms`);
+        }
+        return runBuild(cli.flags).catch((err) => {
+            inline.error(err);
+            process.exit(1);
+        });
+    }
+    return { run };
+}
+export { increaseId, createModeIndexerApp, createIndexerApp };

package/dist/log.d.ts

@@ -0,0 +1,14 @@
+declare function print(o: unknown): string;
+declare function getLine(params: unknown[]): string;
+declare const inline: {
+    debug: (...args: unknown[]) => void;
+    log: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+};
+declare const logger: {
+    debug: (...args: unknown[]) => void;
+    log: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+};
+export { print, getLine, inline, logger };
+//# sourceMappingURL=log.d.ts.map

package/dist/log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log.d.ts","sourceRoot":"","sources":["../log.ts"],"names":[],"mappings":"AAIA,iBAAS,KAAK,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAYjC;AAED,iBAAS,OAAO,CAAC,MAAM,EAAE,OAAO,EAAE,UAWjC;AAMD,QAAA,MAAM,MAAM;qBACgB,OAAO,EAAE;mBAKX,OAAO,EAAE;qBAKP,OAAO,EAAE;CAKpC,CAAC;AAEF,QAAA,MAAM,MAAM;qBACgB,OAAO,EAAE;mBAKX,OAAO,EAAE;qBAKP,OAAO,EAAE;CAKpC,CAAC;AAEF,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC"}

package/dist/log.js

@@ -0,0 +1,62 @@
+function isObject(a) {
+    return !!a && a.constructor === Object;
+}
+function print(o) {
+    if (Array.isArray(o)) {
+        return `[${o.map(print).join(", ")}]`;
+    }
+    if (isObject(o)) {
+        return `{${Object.keys(o)
+            .map((k) => `${k}: ${o[k]}`)
+            .join(", ")}}`;
+    }
+    return `${o}`;
+}
+function getLine(params) {
+    let line = "";
+    // Convert to string and filter out newline to tabs (AWS Athena)
+    for (let i = 0, l = params.length; i < l; i++) {
+        // Certain objects don't get converted
+        // Note using JSON.stringfy may be too slow for large objects
+        line += `${print(params[i])} `.replace(/\n/gm, "\t");
+    }
+    return line.trim();
+}
+function timestamp() {
+    return new Date().toISOString();
+}
+const inline = {
+    debug: function (...args) {
+        if (process.env.NODE_ENV === "development") {
+            console.log(`${timestamp()} ${getLine(args)}`);
+        }
+    },
+    log: function (...args) {
+        if (process.env.NODE_ENV !== "test") {
+            console.log(`${timestamp()} ${getLine(args)}`);
+        }
+    },
+    error: function (...args) {
+        if (process.env.NODE_ENV !== "test") {
+            console.error(`${timestamp()} ${getLine(args)}`);
+        }
+    },
+};
+const logger = {
+    debug: function (...args) {
+        if (process.env.NODE_ENV === "development") {
+            console.log(`[${timestamp()}]`, ...args);
+        }
+    },
+    log: function (...args) {
+        if (process.env.NODE_ENV !== "test") {
+            console.log(`[${timestamp()}]`, ...args);
+        }
+    },
+    error: function (...args) {
+        if (process.env.NODE_ENV !== "test") {
+            console.error(`[${timestamp()}]`, ...args);
+        }
+    },
+};
+export { print, getLine, inline, logger };

package/dist/object-hash.d.ts

@@ -0,0 +1,2 @@
+export declare function getHash(obj: unknown): string;
+//# sourceMappingURL=object-hash.d.ts.map

package/dist/object-hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object-hash.d.ts","sourceRoot":"","sources":["../object-hash.ts"],"names":[],"mappings":"AAEA,wBAAgB,OAAO,CAAC,GAAG,EAAE,OAAO,UAInC"}

package/dist/object-hash.js

@@ -0,0 +1,71 @@
+import xh from "@node-rs/xxhash";
+export function getHash(obj) {
+    const xxh3 = xh.xxh3.Xxh3.withSeed();
+    hash(obj, xxh3);
+    return xxh3.digest().toString(16);
+}
+function hash(obj, xxh3) {
+    if (obj === null) {
+        xxh3.update("null");
+    }
+    else if (obj === undefined) {
+        xxh3.update("undefined");
+    }
+    else if (typeof obj === "string") {
+        xxh3.update(obj);
+    }
+    else if (typeof obj === "number") {
+        xxh3.update(obj.toString());
+    }
+    else if (typeof obj === "boolean") {
+        xxh3.update(obj.toString());
+    }
+    else if (typeof obj === "bigint") {
+        xxh3.update(obj.toString());
+    }
+    else if (obj instanceof Date) {
+        xxh3.update(obj.toISOString());
+    }
+    else if (Array.isArray(obj)) {
+        arrayHash(obj, xxh3);
+    }
+    else if (obj instanceof Set) {
+        setHash(obj, xxh3);
+    }
+    else if (obj instanceof Map) {
+        mapHash(obj, xxh3);
+    }
+    else if (typeof obj === "object") {
+        objectHash(obj, xxh3);
+    }
+    else {
+        throw new Error(`Unsupported type: ${obj}`);
+    }
+}
+function arrayHash(array, xxh3) {
+    xxh3.update("[");
+    for (const obj of array) {
+        hash(obj, xxh3);
+    }
+    xxh3.update("]");
+}
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function setHash(_set, _xxh3) {
+    throw new Error("Set hashing not implemented");
+}
+function mapHash(map, xxh3) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const array = Array.from(map.entries()).sort(([aKey], [bKey]) => aKey.localeCompare(bKey));
+    for (const [key, value] of array) {
+        hash(key, xxh3);
+        hash(value, xxh3);
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function objectHash(obj, xxh3) {
+    const array = Object.entries(obj).sort(([aKey], [bKey]) => aKey.localeCompare(bKey));
+    for (const [key, value] of array) {
+        hash(key, xxh3);
+        hash(value, xxh3);
+    }
+}

package/dist/opsgenie.d.ts

@@ -0,0 +1,21 @@
+type OpsgenieResponse = {
+    data: {
+        success: boolean;
+        action: string;
+        processedAt: string;
+        integrationId: string;
+        isSuccess: boolean;
+        status: string;
+        alertId: string;
+        alias: string;
+    };
+    took: number;
+    requestId: string;
+};
+export declare function postGenieMessage(body: {
+    alias?: string;
+    message: string;
+    description?: string;
+}, apiKey?: string, verbose?: boolean): Promise<OpsgenieResponse>;
+export {};
+//# sourceMappingURL=opsgenie.d.ts.map

package/dist/opsgenie.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opsgenie.d.ts","sourceRoot":"","sources":["../opsgenie.ts"],"names":[],"mappings":"AAEA,KAAK,gBAAgB,GAAG;IACtB,IAAI,EAAE;QACJ,OAAO,EAAE,OAAO,CAAC;QACjB,MAAM,EAAE,MAAM,CAAC;QACf,WAAW,EAAE,MAAM,CAAC;QACpB,aAAa,EAAE,MAAM,CAAC;QACtB,SAAS,EAAE,OAAO,CAAC;QACnB,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,EAAE,MAAM,CAAC;QAChB,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;IACF,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAUF,wBAAsB,gBAAgB,CACpC,IAAI,EAAE;IACJ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,EACD,MAAM,CAAC,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,OAAO,6BAoClB"}