@kensio/yulin 1.19.4 → 1.20.0

package/dist/service/kinesis/sim-kinesis.js

@@ -0,0 +1,132 @@
+import { BackgroundTasks, } from "../../util/background/background.js";
+import { simAwsAccountRegionScopeFactory } from "../aws/sim-aws-account-region-scope.factory.js";
+import { SimIamAllowAllAuth, } from "../iam/authorize/sim-iam-inter-service-auth-z.js";
+import { SimKinesisCommands } from "./command/sim-kinesis-commands.js";
+import { SimKinesisCfnResourceFactory } from "./cfn/sim-kinesis-cfn-resource-factory.js";
+import { SimKinesisSdkCommandRouter } from "./sdk/sim-kinesis-sdk-command-router.js";
+import { SimKinesisStreamActivity } from "./stream/sim-kinesis-stream-activity.js";
+import { SimKinesisStreamStore } from "./stream/sim-kinesis-stream-store.js";
+/**
+ * Simulated Kinesis Data Streams. Handles SDK commands. Emulates AWS behaviour
+ * and state.
+ *
+ * Streams are scoped to an account and region, as they are on real AWS. A
+ * stream name is unique within one of those scopes, and the ARN a request
+ * reaches a stream by names the region.
+ *
+ * A stream's shards are opened when it is created and stay as they are. A
+ * record goes to the shard whose slice of the hash key space its partition key
+ * hashes into, which is how real Kinesis places one, and nothing here splits or
+ * merges a shard afterwards.
+ *
+ * Enhanced fan-out is unsimulated. A consumer reads through `GetRecords`, which
+ * is the shared throughput path every stream has.
+ */
+export class SimKinesis {
+    streams = new SimKinesisStreamStore();
+    activity = new SimKinesisStreamActivity();
+    commands;
+    background;
+    sdkRouter = new SimKinesisSdkCommandRouter(this);
+    cfnFactory = new SimKinesisCfnResourceFactory({
+        kinesis: this,
+    });
+    constructor(properties = {}) {
+        const { accountRegionScope = simAwsAccountRegionScopeFactory.make(), iam = new SimIamAllowAllAuth(), background = new BackgroundTasks(), } = properties;
+        this.background = background;
+        this.commands = new SimKinesisCommands({
+            streams: this.streams,
+            activity: this.activity,
+            iam,
+            background,
+            accountRegionScope,
+        });
+    }
+    /**
+     * Find a stream by name.
+     *
+     * This is the simulator's own accessor, for tests seeding or inspecting
+     * stream state without going through a Command and its authorization.
+     */
+    findStream(name) {
+        return this.streams.find(name);
+    }
+    /**
+     * Get the streams of this service, for a consumer that cannot poll them
+     * continuously.
+     *
+     * A Lambda event source mapping is what this exists for. It says when a
+     * record has been put, so a poller has something to wake on.
+     */
+    streamActivity() {
+        return this.activity;
+    }
+    /** Handle a CreateStream Command from the SDK. */
+    async createStream(command, options) {
+        await this.background.sequence();
+        return this.commands.streamCreation.handle(command, options);
+    }
+    /** Handle a DeleteStream Command from the SDK. */
+    async deleteStream(command, options) {
+        await this.background.sequence();
+        return this.commands.streams.deleteStream(command, options);
+    }
+    /** Handle a ListStreams Command from the SDK. */
+    async listStreams(command, options) {
+        await this.background.sequence();
+        return this.commands.streams.listStreams(command, options);
+    }
+    /** Handle a DescribeStream Command from the SDK. */
+    async describeStream(command, options) {
+        await this.background.sequence();
+        return this.commands.streams.describeStream(command, options);
+    }
+    /** Handle a DescribeStreamSummary Command from the SDK. */
+    async describeStreamSummary(command, options) {
+        await this.background.sequence();
+        return this.commands.streams.describeStreamSummary(command, options);
+    }
+    /** Handle an IncreaseStreamRetentionPeriod Command from the SDK. */
+    async increaseStreamRetentionPeriod(command, options) {
+        await this.background.sequence();
+        return this.commands.retention.increase(command, options);
+    }
+    /** Handle a DecreaseStreamRetentionPeriod Command from the SDK. */
+    async decreaseStreamRetentionPeriod(command, options) {
+        await this.background.sequence();
+        return this.commands.retention.decrease(command, options);
+    }
+    /** Handle a PutRecord Command from the SDK. */
+    async putRecord(command, options) {
+        await this.background.sequence();
+        return this.commands.puts.putRecord(command, options);
+    }
+    /** Handle a PutRecords Command from the SDK. */
+    async putRecords(command, options) {
+        await this.background.sequence();
+        return this.commands.puts.putRecords(command, options);
+    }
+    /** Handle a GetShardIterator Command from the SDK. */
+    async getShardIterator(command, options) {
+        await this.background.sequence();
+        return this.commands.reads.getShardIterator(command, options);
+    }
+    /** Handle a GetRecords Command from the SDK. */
+    async getRecords(command, options) {
+        await this.background.sequence();
+        return this.commands.reads.getRecords(command, options);
+    }
+    /**
+     * Get this service's SDK Command router for SDK client interception.
+     */
+    sdkCommandRouter() {
+        return this.sdkRouter;
+    }
+    /**
+     * Get this service's CloudFormation Resource factory.
+     */
+    cfnResourceFactory() {
+        return this.cfnFactory;
+    }
+}
+//# sourceMappingURL=sim-kinesis.js.map

package/dist/service/kinesis/sim-kinesis.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-kinesis.js","sourceRoot":"","sources":["../../../src/service/kinesis/sim-kinesis.ts"],"names":[],"mappings":"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"}

package/dist/service/kinesis/stream/sim-kinesis-hash-key.d.ts

@@ -0,0 +1,33 @@
+/**
+ * How many hash keys the space a stream's shards divide holds.
+ *
+ * Kinesis hashes a partition key to a 128 bit unsigned integer, so the space
+ * runs from zero to one less than this.
+ */
+export declare const simKinesisHashKeySpace: bigint;
+/**
+ * The 128 bit hash key a partition key falls on.
+ *
+ * This is MD5 read as a big-endian unsigned integer, which is what real Kinesis
+ * does. The hash is a placement function rather than a security one, so MD5
+ * being broken is beside the point: using anything else would put a record on a
+ * different shard from the one AWS would have put it on.
+ */
+export declare function simKinesisPartitionKeyHash(partitionKey: string): bigint;
+/**
+ * The half-open bounds of one shard's slice of the hash key space.
+ */
+export interface SimKinesisHashKeyRange {
+    readonly startingHashKey: bigint;
+    readonly endingHashKey: bigint;
+}
+/**
+ * Divide the hash key space between a number of shards.
+ *
+ * The slices are equal and adjacent, with the last one taking whatever the
+ * division left over, so together they cover the whole space with no gap and no
+ * overlap. That is what real Kinesis gives a stream created with a shard count,
+ * before anything reshards it.
+ */
+export declare function simKinesisHashKeyRanges(shardCount: number): readonly SimKinesisHashKeyRange[];
+//# sourceMappingURL=sim-kinesis-hash-key.d.ts.map

package/dist/service/kinesis/stream/sim-kinesis-hash-key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-kinesis-hash-key.d.ts","sourceRoot":"","sources":["../../../../src/service/kinesis/stream/sim-kinesis-hash-key.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,QAAa,CAAC;AAEjD;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAIvE;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,MAAM,GACjB,SAAS,sBAAsB,EAAE,CAUnC"}

package/dist/service/kinesis/stream/sim-kinesis-hash-key.js

@@ -0,0 +1,38 @@
+import { createHash } from "node:crypto";
+/**
+ * How many hash keys the space a stream's shards divide holds.
+ *
+ * Kinesis hashes a partition key to a 128 bit unsigned integer, so the space
+ * runs from zero to one less than this.
+ */
+export const simKinesisHashKeySpace = 2n ** 128n;
+/**
+ * The 128 bit hash key a partition key falls on.
+ *
+ * This is MD5 read as a big-endian unsigned integer, which is what real Kinesis
+ * does. The hash is a placement function rather than a security one, so MD5
+ * being broken is beside the point: using anything else would put a record on a
+ * different shard from the one AWS would have put it on.
+ */
+export function simKinesisPartitionKeyHash(partitionKey) {
+    const digest = createHash("md5").update(partitionKey, "utf8").digest("hex");
+    return BigInt(`0x${digest}`);
+}
+/**
+ * Divide the hash key space between a number of shards.
+ *
+ * The slices are equal and adjacent, with the last one taking whatever the
+ * division left over, so together they cover the whole space with no gap and no
+ * overlap. That is what real Kinesis gives a stream created with a shard count,
+ * before anything reshards it.
+ */
+export function simKinesisHashKeyRanges(shardCount) {
+    const span = simKinesisHashKeySpace / BigInt(shardCount);
+    return Array.from({ length: shardCount }, (_unused, index) => ({
+        startingHashKey: span * BigInt(index),
+        endingHashKey: (index === shardCount - 1
+            ? simKinesisHashKeySpace
+            : span * BigInt(index + 1)) - 1n,
+    }));
+}
+//# sourceMappingURL=sim-kinesis-hash-key.js.map

package/dist/service/kinesis/stream/sim-kinesis-hash-key.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-kinesis-hash-key.js","sourceRoot":"","sources":["../../../../src/service/kinesis/stream/sim-kinesis-hash-key.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,EAAE,IAAI,IAAI,CAAC;AAEjD;;;;;;;GAOG;AACH,MAAM,UAAU,0BAA0B,CAAC,YAAoB;IAC7D,MAAM,MAAM,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAE5E,OAAO,MAAM,CAAC,KAAK,MAAM,EAAE,CAAC,CAAC;AAC/B,CAAC;AAUD;;;;;;;GAOG;AACH,MAAM,UAAU,uBAAuB,CACrC,UAAkB;IAElB,MAAM,IAAI,GAAG,sBAAsB,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;IAEzD,OAAO,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,EAAE,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC;QAC7D,eAAe,EAAE,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC;QACrC,aAAa,EACX,CAAC,KAAK,KAAK,UAAU,GAAG,CAAC;YACvB,CAAC,CAAC,sBAAsB;YACxB,CAAC,CAAC,IAAI,GAAG,MAAM,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE;KACrC,CAAC,CAAC,CAAC;AACN,CAAC"}

package/dist/service/kinesis/stream/sim-kinesis-record.d.ts

@@ -0,0 +1,28 @@
+interface SimKinesisRecordProperties {
+    readonly partitionKey: string;
+    readonly explicitHashKey: bigint | undefined;
+    readonly data: Uint8Array;
+    readonly sequenceNumber: string;
+    readonly arrivedAt: Date;
+}
+/**
+ * One record on one shard of one stream.
+ *
+ * The data is a copy of the bytes the caller put. Real Kinesis serializes a
+ * record on the way in, so a producer reusing one buffer for record after
+ * record puts a different record each time. Holding the caller's array would
+ * make every record on the stream change together as that buffer was refilled.
+ *
+ * The bytes themselves are carried unchanged. A consumer decoding JSON, Avro or
+ * anything else gets what the producer encoded.
+ */
+export declare class SimKinesisRecord {
+    readonly partitionKey: string;
+    readonly explicitHashKey: bigint | undefined;
+    readonly data: Uint8Array;
+    readonly sequenceNumber: string;
+    readonly arrivedAt: Date;
+    constructor(properties: SimKinesisRecordProperties);
+}
+export {};
+//# sourceMappingURL=sim-kinesis-record.d.ts.map

package/dist/service/kinesis/stream/sim-kinesis-record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-kinesis-record.d.ts","sourceRoot":"","sources":["../../../../src/service/kinesis/stream/sim-kinesis-record.ts"],"names":[],"mappings":"AAAA,UAAU,0BAA0B;IAClC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7C,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC;CAC1B;AAED;;;;;;;;;;GAUG;AACH,qBAAa,gBAAgB;IAC3B,SAAgB,YAAY,EAAE,MAAM,CAAC;IACrC,SAAgB,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;IACpD,SAAgB,IAAI,EAAE,UAAU,CAAC;IACjC,SAAgB,cAAc,EAAE,MAAM,CAAC;IACvC,SAAgB,SAAS,EAAE,IAAI,CAAC;IAEhC,YAAY,UAAU,EAAE,0BAA0B,EAMjD;CACF"}

package/dist/service/kinesis/stream/sim-kinesis-record.js

@@ -0,0 +1,26 @@
+/**
+ * One record on one shard of one stream.
+ *
+ * The data is a copy of the bytes the caller put. Real Kinesis serializes a
+ * record on the way in, so a producer reusing one buffer for record after
+ * record puts a different record each time. Holding the caller's array would
+ * make every record on the stream change together as that buffer was refilled.
+ *
+ * The bytes themselves are carried unchanged. A consumer decoding JSON, Avro or
+ * anything else gets what the producer encoded.
+ */
+export class SimKinesisRecord {
+    partitionKey;
+    explicitHashKey;
+    data;
+    sequenceNumber;
+    arrivedAt;
+    constructor(properties) {
+        this.partitionKey = properties.partitionKey;
+        this.explicitHashKey = properties.explicitHashKey;
+        this.data = Uint8Array.from(properties.data);
+        this.sequenceNumber = properties.sequenceNumber;
+        this.arrivedAt = new Date(properties.arrivedAt);
+    }
+}
+//# sourceMappingURL=sim-kinesis-record.js.map

package/dist/service/kinesis/stream/sim-kinesis-record.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-kinesis-record.js","sourceRoot":"","sources":["../../../../src/service/kinesis/stream/sim-kinesis-record.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;GAUG;AACH,MAAM,OAAO,gBAAgB;IACX,YAAY,CAAS;IACrB,eAAe,CAAqB;IACpC,IAAI,CAAa;IACjB,cAAc,CAAS;IACvB,SAAS,CAAO;IAEhC,YAAY,UAAsC;QAChD,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC,YAAY,CAAC;QAC5C,IAAI,CAAC,eAAe,GAAG,UAAU,CAAC,eAAe,CAAC;QAClD,IAAI,CAAC,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QAC7C,IAAI,CAAC,cAAc,GAAG,UAAU,CAAC,cAAc,CAAC;QAChD,IAAI,CAAC,SAAS,GAAG,IAAI,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;IAClD,CAAC;CACF"}

package/dist/service/kinesis/stream/sim-kinesis-retention.d.ts

@@ -0,0 +1,27 @@
+/**
+ * How long a stream keeps a record when nothing says otherwise.
+ */
+export declare const simKinesisDefaultRetentionHours = 24;
+/**
+ * The shortest retention real Kinesis accepts.
+ */
+export declare const simKinesisMinimumRetentionHours = 24;
+/**
+ * The longest retention real Kinesis accepts, which is 365 days.
+ */
+export declare const simKinesisMaximumRetentionHours = 8760;
+/**
+ * Read the retention a request asked for, refusing one outside the range real
+ * Kinesis accepts.
+ */
+export declare function simKinesisRetentionHours(hours: number): number;
+/**
+ * The instant a stream's records have to be newer than to still be readable.
+ *
+ * Trimming is applied when a stream is read rather than scheduled, because it
+ * is a pure function of the current time. Whatever a read finds is what the
+ * retention window holds at the instant of that read, and nothing has to have
+ * run in between for that to be true.
+ */
+export declare function simKinesisTrimPoint(now: Date, retentionHours: number): Date;
+//# sourceMappingURL=sim-kinesis-retention.d.ts.map

package/dist/service/kinesis/stream/sim-kinesis-retention.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-kinesis-retention.d.ts","sourceRoot":"","sources":["../../../../src/service/kinesis/stream/sim-kinesis-retention.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,eAAO,MAAM,+BAA+B,KAAK,CAAC;AAElD;;GAEG;AACH,eAAO,MAAM,+BAA+B,KAAK,CAAC;AAElD;;GAEG;AACH,eAAO,MAAM,+BAA+B,OAAO,CAAC;AAEpD;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAc9D;AAID;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,IAAI,EAAE,cAAc,EAAE,MAAM,GAAG,IAAI,CAE3E"}

package/dist/service/kinesis/stream/sim-kinesis-retention.js

@@ -0,0 +1,40 @@
+import { SimKinesisInvalidArgumentException } from "../error/sim-kinesis.error.js";
+/**
+ * How long a stream keeps a record when nothing says otherwise.
+ */
+export const simKinesisDefaultRetentionHours = 24;
+/**
+ * The shortest retention real Kinesis accepts.
+ */
+export const simKinesisMinimumRetentionHours = 24;
+/**
+ * The longest retention real Kinesis accepts, which is 365 days.
+ */
+export const simKinesisMaximumRetentionHours = 8760;
+/**
+ * Read the retention a request asked for, refusing one outside the range real
+ * Kinesis accepts.
+ */
+export function simKinesisRetentionHours(hours) {
+    if (!Number.isSafeInteger(hours) ||
+        hours < simKinesisMinimumRetentionHours ||
+        hours > simKinesisMaximumRetentionHours) {
+        throw new SimKinesisInvalidArgumentException(`RetentionPeriodHours ${hours} is outside the ` +
+            `${simKinesisMinimumRetentionHours} to ` +
+            `${simKinesisMaximumRetentionHours} hours Kinesis accepts`);
+    }
+    return hours;
+}
+const millisecondsPerHour = 60 * 60 * 1000;
+/**
+ * The instant a stream's records have to be newer than to still be readable.
+ *
+ * Trimming is applied when a stream is read rather than scheduled, because it
+ * is a pure function of the current time. Whatever a read finds is what the
+ * retention window holds at the instant of that read, and nothing has to have
+ * run in between for that to be true.
+ */
+export function simKinesisTrimPoint(now, retentionHours) {
+    return new Date(now.getTime() - retentionHours * millisecondsPerHour);
+}
+//# sourceMappingURL=sim-kinesis-retention.js.map

package/dist/service/kinesis/stream/sim-kinesis-retention.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-kinesis-retention.js","sourceRoot":"","sources":["../../../../src/service/kinesis/stream/sim-kinesis-retention.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kCAAkC,EAAE,MAAM,+BAA+B,CAAC;AAEnF;;GAEG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAAG,EAAE,CAAC;AAElD;;GAEG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAAG,EAAE,CAAC;AAElD;;GAEG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAAG,IAAI,CAAC;AAEpD;;;GAGG;AACH,MAAM,UAAU,wBAAwB,CAAC,KAAa;IACpD,IACE,CAAC,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC;QAC5B,KAAK,GAAG,+BAA+B;QACvC,KAAK,GAAG,+BAA+B,EACvC,CAAC;QACD,MAAM,IAAI,kCAAkC,CAC1C,wBAAwB,KAAK,kBAAkB;YAC7C,GAAG,+BAA+B,MAAM;YACxC,GAAG,+BAA+B,wBAAwB,CAC7D,CAAC;IACJ,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED,MAAM,mBAAmB,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;AAE3C;;;;;;;GAOG;AACH,MAAM,UAAU,mBAAmB,CAAC,GAAS,EAAE,cAAsB;IACnE,OAAO,IAAI,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,GAAG,cAAc,GAAG,mBAAmB,CAAC,CAAC;AACxE,CAAC"}

package/dist/service/kinesis/stream/sim-kinesis-sequence-numbers.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The sequence numbers one stream hands out.
+ *
+ * This is a counter rather than a clock. Records are commonly put inside one
+ * millisecond, and a clock cannot tell those apart, which would leave two
+ * records claiming the same position on the stream.
+ *
+ * One counter serves the whole stream rather than one per shard. Real Kinesis
+ * promises a sequence number is unique within a stream and increases within a
+ * shard, and a single counter gives both. It also means two records on
+ * different shards can be ordered against each other here, which real Kinesis
+ * does not promise. A consumer relying on that would be relying on something
+ * AWS does not offer.
+ */
+export declare class SimKinesisSequenceNumbers {
+    private next;
+    /**
+     * Take the next sequence number, as the text a record carries.
+     */
+    take(): string;
+}
+/**
+ * Order two sequence numbers.
+ *
+ * They are compared as numbers rather than as text. The width is fixed while a
+ * simulation runs, so the two orders agree, and comparing the values keeps that
+ * true if the width ever changes.
+ */
+export declare function compareSimKinesisSequenceNumbers(left: string, right: string): number;
+//# sourceMappingURL=sim-kinesis-sequence-numbers.d.ts.map

package/dist/service/kinesis/stream/sim-kinesis-sequence-numbers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-kinesis-sequence-numbers.d.ts","sourceRoot":"","sources":["../../../../src/service/kinesis/stream/sim-kinesis-sequence-numbers.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;GAaG;AACH,qBAAa,yBAAyB;IACpC,OAAO,CAAC,IAAI,CAAuB;IAEnC;;OAEG;IACH,IAAI,IAAI,MAAM,CAKb;CACF;AAED;;;;;;GAMG;AACH,wBAAgB,gCAAgC,CAC9C,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,GACZ,MAAM,CAQR"}

package/dist/service/kinesis/stream/sim-kinesis-sequence-numbers.js

@@ -0,0 +1,49 @@
+/**
+ * The number the first record on a stream is given.
+ *
+ * A sequence number is compared as text by anything reading a stream, so the
+ * width has to be fixed and the first digit has to be something other than a
+ * zero. Real Kinesis hands out 56 digit numbers, and starting at 10^55 gives
+ * that width with room for more records than any simulation will write.
+ */
+const firstSequenceNumber = 10n ** 55n;
+/**
+ * The sequence numbers one stream hands out.
+ *
+ * This is a counter rather than a clock. Records are commonly put inside one
+ * millisecond, and a clock cannot tell those apart, which would leave two
+ * records claiming the same position on the stream.
+ *
+ * One counter serves the whole stream rather than one per shard. Real Kinesis
+ * promises a sequence number is unique within a stream and increases within a
+ * shard, and a single counter gives both. It also means two records on
+ * different shards can be ordered against each other here, which real Kinesis
+ * does not promise. A consumer relying on that would be relying on something
+ * AWS does not offer.
+ */
+export class SimKinesisSequenceNumbers {
+    next = firstSequenceNumber;
+    /**
+     * Take the next sequence number, as the text a record carries.
+     */
+    take() {
+        const taken = this.next;
+        this.next += 1n;
+        return taken.toString();
+    }
+}
+/**
+ * Order two sequence numbers.
+ *
+ * They are compared as numbers rather than as text. The width is fixed while a
+ * simulation runs, so the two orders agree, and comparing the values keeps that
+ * true if the width ever changes.
+ */
+export function compareSimKinesisSequenceNumbers(left, right) {
+    const difference = BigInt(left) - BigInt(right);
+    if (difference === 0n) {
+        return 0;
+    }
+    return difference > 0n ? 1 : -1;
+}
+//# sourceMappingURL=sim-kinesis-sequence-numbers.js.map

package/dist/service/kinesis/stream/sim-kinesis-sequence-numbers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-kinesis-sequence-numbers.js","sourceRoot":"","sources":["../../../../src/service/kinesis/stream/sim-kinesis-sequence-numbers.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,mBAAmB,GAAG,GAAG,IAAI,GAAG,CAAC;AAEvC;;;;;;;;;;;;;GAaG;AACH,MAAM,OAAO,yBAAyB;IAC5B,IAAI,GAAG,mBAAmB,CAAC;IAEnC;;OAEG;IACH,IAAI;QACF,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC;QACxB,IAAI,CAAC,IAAI,IAAI,EAAE,CAAC;QAEhB,OAAO,KAAK,CAAC,QAAQ,EAAE,CAAC;IAC1B,CAAC;CACF;AAED;;;;;;GAMG;AACH,MAAM,UAAU,gCAAgC,CAC9C,IAAY,EACZ,KAAa;IAEb,MAAM,UAAU,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IAEhD,IAAI,UAAU,KAAK,EAAE,EAAE,CAAC;QACtB,OAAO,CAAC,CAAC;IACX,CAAC;IAED,OAAO,UAAU,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAClC,CAAC"}

package/dist/service/kinesis/stream/sim-kinesis-shard-iterator.d.ts

@@ -0,0 +1,25 @@
+import type { SimKinesisStreamPosition } from "./sim-kinesis-stream-position.js";
+/**
+ * What a shard iterator stands for: one place on one shard of one stream.
+ */
+export interface SimKinesisShardIterator {
+    readonly streamArn: string;
+    readonly shardId: string;
+    readonly position: SimKinesisStreamPosition;
+}
+/**
+ * The opaque token a caller is handed to read on from a place.
+ *
+ * Real shard iterators are opaque strings a caller passes back unread, and this
+ * one is the same shape. The place it stands for travels inside it rather than
+ * in a table of handed-out iterators, which is what lets an iterator be used
+ * against the stream it names without the stream having to remember it. That is
+ * also why the five minute expiry is deliberately absent here rather than
+ * approximated.
+ */
+export declare function simKinesisShardIteratorToken(iterator: SimKinesisShardIterator): string;
+/**
+ * Read the place a shard iterator a request carries stands for.
+ */
+export declare function readSimKinesisShardIteratorToken(token: string | undefined): SimKinesisShardIterator;
+//# sourceMappingURL=sim-kinesis-shard-iterator.d.ts.map

package/dist/service/kinesis/stream/sim-kinesis-shard-iterator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-kinesis-shard-iterator.d.ts","sourceRoot":"","sources":["../../../../src/service/kinesis/stream/sim-kinesis-shard-iterator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAEjF;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,wBAAwB,CAAC;CAC7C;AA2DD;;;;;;;;;GASG;AACH,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,uBAAuB,GAChC,MAAM,CAER;AAED;;GAEG;AACH,wBAAgB,gCAAgC,CAC9C,KAAK,EAAE,MAAM,GAAG,SAAS,GACxB,uBAAuB,CA0BzB"}

package/dist/service/kinesis/stream/sim-kinesis-shard-iterator.js

@@ -0,0 +1,84 @@
+import { isRecord } from "../../../util/type-guard/record.js";
+import { SimKinesisExpiredIteratorException } from "../error/sim-kinesis.error.js";
+/**
+ * The four position kinds, as a value read back out of a token has to be one of
+ * them before it is trusted.
+ */
+const positionKinds = new Set(["start", "at", "after", "timestamp"]);
+/**
+ * Refuse a shard iterator a request carries that this simulation never made.
+ *
+ * Real Kinesis reports an iterator it will not accept as expired, which is what
+ * an unreadable one is here: something that was never valid, or is no longer.
+ */
+function refuse() {
+    throw new SimKinesisExpiredIteratorException("The provided ShardIterator is not valid");
+}
+/**
+ * Read a position back out of a decoded token.
+ */
+function readPosition(value) {
+    if (!isRecord(value) || typeof value["kind"] !== "string") {
+        refuse();
+    }
+    const kind = value["kind"];
+    if (!positionKinds.has(kind)) {
+        refuse();
+    }
+    if (kind === "start") {
+        return { kind: "start" };
+    }
+    if (kind === "timestamp") {
+        const epochMillis = value["epochMillis"];
+        if (typeof epochMillis !== "number") {
+            refuse();
+        }
+        return { kind: "timestamp", epochMillis };
+    }
+    const sequenceNumber = value["sequenceNumber"];
+    if (typeof sequenceNumber !== "string") {
+        refuse();
+    }
+    return kind === "at"
+        ? { kind: "at", sequenceNumber }
+        : { kind: "after", sequenceNumber };
+}
+/**
+ * The opaque token a caller is handed to read on from a place.
+ *
+ * Real shard iterators are opaque strings a caller passes back unread, and this
+ * one is the same shape. The place it stands for travels inside it rather than
+ * in a table of handed-out iterators, which is what lets an iterator be used
+ * against the stream it names without the stream having to remember it. That is
+ * also why the five minute expiry is deliberately absent here rather than
+ * approximated.
+ */
+export function simKinesisShardIteratorToken(iterator) {
+    return Buffer.from(JSON.stringify(iterator), "utf8").toString("base64url");
+}
+/**
+ * Read the place a shard iterator a request carries stands for.
+ */
+export function readSimKinesisShardIteratorToken(token) {
+    if (token === undefined || token === "") {
+        refuse();
+    }
+    let decoded;
+    try {
+        decoded = JSON.parse(Buffer.from(token, "base64url").toString("utf8"));
+    }
+    catch {
+        refuse();
+    }
+    if (!isRecord(decoded) ||
+        typeof decoded["streamArn"] !== "string" ||
+        typeof decoded["shardId"] !== "string") {
+        refuse();
+    }
+    return {
+        streamArn: decoded["streamArn"],
+        shardId: decoded["shardId"],
+        position: readPosition(decoded["position"]),
+    };
+}
+//# sourceMappingURL=sim-kinesis-shard-iterator.js.map

package/dist/service/kinesis/stream/sim-kinesis-shard-iterator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-kinesis-shard-iterator.js","sourceRoot":"","sources":["../../../../src/service/kinesis/stream/sim-kinesis-shard-iterator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,oCAAoC,CAAC;AAC9D,OAAO,EAAE,kCAAkC,EAAE,MAAM,+BAA+B,CAAC;AAYnF;;;GAGG;AACH,MAAM,aAAa,GAAG,IAAI,GAAG,CAAC,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC;AAErE;;;;;GAKG;AACH,SAAS,MAAM;IACb,MAAM,IAAI,kCAAkC,CAC1C,yCAAyC,CAC1C,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,SAAS,YAAY,CAAC,KAAc;IAClC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,OAAO,KAAK,CAAC,MAAM,CAAC,KAAK,QAAQ,EAAE,CAAC;QAC1D,MAAM,EAAE,CAAC;IACX,CAAC;IAED,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC;IAE3B,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QAC7B,MAAM,EAAE,CAAC;IACX,CAAC;IAED,IAAI,IAAI,KAAK,OAAO,EAAE,CAAC;QACrB,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;IAC3B,CAAC;IAED,IAAI,IAAI,KAAK,WAAW,EAAE,CAAC;QACzB,MAAM,WAAW,GAAG,KAAK,CAAC,aAAa,CAAC,CAAC;QAEzC,IAAI,OAAO,WAAW,KAAK,QAAQ,EAAE,CAAC;YACpC,MAAM,EAAE,CAAC;QACX,CAAC;QAED,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,WAAW,EAAE,CAAC;IAC5C,CAAC;IAED,MAAM,cAAc,GAAG,KAAK,CAAC,gBAAgB,CAAC,CAAC;IAE/C,IAAI,OAAO,cAAc,KAAK,QAAQ,EAAE,CAAC;QACvC,MAAM,EAAE,CAAC;IACX,CAAC;IAED,OAAO,IAAI,KAAK,IAAI;QAClB,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,cAAc,EAAE;QAChC,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,cAAc,EAAE,CAAC;AACxC,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,4BAA4B,CAC1C,QAAiC;IAEjC,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;AAC7E,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,gCAAgC,CAC9C,KAAyB;IAEzB,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,EAAE,EAAE,CAAC;QACxC,MAAM,EAAE,CAAC;IACX,CAAC;IAED,IAAI,OAAgB,CAAC;IAErB,IAAI,CAAC;QACH,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;IACzE,CAAC;IAAC,MAAM,CAAC;QACP,MAAM,EAAE,CAAC;IACX,CAAC;IAED,IACE,CAAC,QAAQ,CAAC,OAAO,CAAC;QAClB,OAAO,OAAO,CAAC,WAAW,CAAC,KAAK,QAAQ;QACxC,OAAO,OAAO,CAAC,SAAS,CAAC,KAAK,QAAQ,EACtC,CAAC;QACD,MAAM,EAAE,CAAC;IACX,CAAC;IAED,OAAO;QACL,SAAS,EAAE,OAAO,CAAC,WAAW,CAAC;QAC/B,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC;QAC3B,QAAQ,EAAE,YAAY,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;KAC5C,CAAC;AACJ,CAAC"}

package/dist/service/kinesis/stream/sim-kinesis-shard-map.d.ts

@@ -0,0 +1,34 @@
+import type { SimKinesisSequenceNumbers } from "./sim-kinesis-sequence-numbers.js";
+import { SimKinesisShard } from "./sim-kinesis-shard.js";
+interface SimKinesisShardMapProperties {
+    readonly shardCount: number;
+    readonly sequenceNumbers: SimKinesisSequenceNumbers;
+}
+/**
+ * The shards of one stream, and which slice of the hash key space each holds.
+ *
+ * The shards are opened together and stay as they are. Nothing here splits or
+ * merges one, so a record's shard is decided by its hash key alone and stays
+ * decidable for the life of the stream.
+ */
+export declare class SimKinesisShardMap {
+    readonly shards: readonly SimKinesisShard[];
+    constructor(properties: SimKinesisShardMapProperties);
+    /**
+     * Find a shard by its identifier.
+     */
+    find(shardId: string): SimKinesisShard | undefined;
+    /**
+     * The shard whose slice of the hash key space a key falls in.
+     *
+     * The ranges cover the whole space between them, so one of them always
+     * matches whatever a 128 bit hash lands on.
+     */
+    covering(hashKey: bigint): SimKinesisShard;
+    /**
+     * Drop the records put before an instant, on every shard.
+     */
+    trim(before: Date): void;
+}
+export {};
+//# sourceMappingURL=sim-kinesis-shard-map.d.ts.map

package/dist/service/kinesis/stream/sim-kinesis-shard-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-kinesis-shard-map.d.ts","sourceRoot":"","sources":["../../../../src/service/kinesis/stream/sim-kinesis-shard-map.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAC;AACnF,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEzD,UAAU,4BAA4B;IACpC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,eAAe,EAAE,yBAAyB,CAAC;CACrD;AAED;;;;;;GAMG;AACH,qBAAa,kBAAkB;IAC7B,SAAgB,MAAM,EAAE,SAAS,eAAe,EAAE,CAAC;IAEnD,YAAY,UAAU,EAAE,4BAA4B,EASnD;IAED;;OAEG;IACH,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS,CAEjD;IAED;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe,CAKzC;IAED;;OAEG;IACH,IAAI,CAAC,MAAM,EAAE,IAAI,GAAG,IAAI,CAIvB;CACF"}