@sprucelabs/mercury-chunking-emitter 1.1.1 → 1.1.2

package/src/chunkingEmitter/ChunkingEmitter.ts

@@ -1,107 +0,0 @@
-import { MercuryClient } from '@sprucelabs/mercury-client'
-import { EventName } from '@sprucelabs/mercury-types'
-import { assertOptions } from '@sprucelabs/schema'
-import { buildLog } from '@sprucelabs/spruce-skill-utils'
-
-export default class ChunkingEmitterImpl {
-	private client: MercuryClient
-	protected chunkSize: number
-	private log = buildLog('ChunkingEmitter')
-	public static Class?: new (options: ChunkingEmitterOptions) => ChunkingEmitter
-	private totalErrors = 0
-
-	protected constructor(options: ChunkingEmitterOptions) {
-		const { client, chunkSize } = assertOptions(options, ['client'])
-		this.client = client
-		this.chunkSize = chunkSize ?? 10
-	}
-
-	public static async Emitter(options: ChunkingEmitterOptions) {
-		assertOptions(options, ['client'])
-		return new (this.Class ?? this)(options)
-	}
-
-	public async emit(options: ChunkingEmitterEmitOptions) {
-		const { eventName, items, payloadKey, target } = assertOptions(options, [
-			'eventName',
-			'items',
-			'payloadKey',
-		])
-
-		this.totalErrors = 0
-		const chunks = this.splitItemsIntoChunks(items)
-		let current = 0
-
-		for (const chunk of chunks) {
-			try {
-				let targetAndPayload: Record<string, any> = {
-					payload: {
-						[payloadKey]: chunk,
-						chunk: {
-							current: current++,
-							total: chunks.length,
-						},
-					},
-				}
-
-				if (target) {
-					targetAndPayload.target = target
-				}
-
-				await this.client.emitAndFlattenResponses(
-					eventName as EventName,
-					targetAndPayload
-				)
-			} catch (err: any) {
-				this.log.error('Failed to emit chunk', err)
-				this.totalErrors++
-			}
-		}
-	}
-
-	public static reset() {
-		this.Class = undefined
-	}
-
-	private splitItemsIntoChunks(items: Record<string, any>[]) {
-		const chunks: Record<string, any>[][] = []
-
-		let index = 0
-
-		for (const item of items) {
-			if (!chunks[index]) {
-				chunks[index] = []
-			}
-
-			if (chunks[index].length === this.chunkSize) {
-				index++
-				chunks[index] = []
-			}
-
-			chunks[index].push(item)
-		}
-
-		return chunks
-	}
-
-	public getTotalErrors(): number {
-		return this.totalErrors
-	}
-}
-
-interface ChunkingEmitterOptions {
-	client: MercuryClient
-	chunkSize?: number
-}
-
-type ChunkingEmitterEmitOptions = {
-	eventName: EventName
-	items: Record<string, any>[]
-	payloadKey: string
-	target?: Record<string, any>
-}
-
-export interface ChunkingEmitter {
-	emit(options: ChunkingEmitterEmitOptions): Promise<void>
-	getTotalErrors(): number
-}

package/src/chunkingEmitter/MockChunkingEmitter.ts

@@ -1,101 +0,0 @@
-import { MercuryTestClient } from '@sprucelabs/mercury-client'
-import { EventName } from '@sprucelabs/mercury-types'
-import { assert } from '@sprucelabs/test-utils'
-import { chunkFieldDefinition } from './chunkFieldDefinition'
-import { ChunkingEmitter } from './ChunkingEmitter'
-
-export default class MockChunkingEmitter implements ChunkingEmitter {
-	private didEmit = false
-	private emittedEventName?: EventName
-	private emittedItems?: Record<string, unknown>[]
-	private emittedPayloadKey?: string
-	public static lastInstance?: MockChunkingEmitter
-
-	public constructor() {
-		MockChunkingEmitter.lastInstance = this
-	}
-
-	public static getLastInstance() {
-		assert.isTruthy(
-			this.lastInstance,
-			'You have not constructed a ChunkingEmitter! Try ChunkingEmitterImpl.Emitter({})'
-		)
-		return this.lastInstance
-	}
-
-	public static reset() {
-		this.lastInstance = undefined
-	}
-
-	public async emit(options: {
-		eventName: EventName
-		items: Record<string, unknown>[]
-		payloadKey: string
-	}): Promise<void> {
-		const { eventName, items, payloadKey } = options
-		this.didEmit = true
-		this.emittedEventName = eventName
-		this.emittedItems = items
-		this.emittedPayloadKey = payloadKey
-	}
-
-	public assertDidEmitPayloadKey(payloadKey: string) {
-		this.assertDidEmit()
-		assert.isEqual(
-			this.emittedPayloadKey,
-			payloadKey,
-			`I expected chunkingEmitter.emit() with payloadKey '${payloadKey}'! But you emitted ${
-				this.emittedPayloadKey || 'nothing'
-			}`
-		)
-	}
-
-	public getTotalErrors(): number {
-		return 0
-	}
-
-	public assertEmittedItems(items: Record<string, any>[]) {
-		this.assertDidEmit()
-		assert.isEqualDeep(
-			this.emittedItems,
-			items,
-			'You did not chunkingEmitter.emit(...) the expected items!!'
-		)
-	}
-
-	public assertDidEmit() {
-		assert.isTrue(
-			this.didEmit,
-			`You did not ever call chunkingEmitter.emit(...). That is your next step!`
-		)
-	}
-
-	public assertDidEmitEventNamed(fqen: EventName) {
-		this.assertDidEmit()
-		assert.isEqual(
-			this.emittedEventName,
-			fqen,
-			`I expected chunkingEmitter to emit '${fqen}'! But you emitted ${
-				this.emittedEventName || 'nothing'
-			}`
-		)
-	}
-
-	public assertEventHonorsChunkingSignature(fqen: EventName) {
-		const emitter = MercuryTestClient.getInternalEmitter()
-		const contract = emitter.getContract()
-		const payload = contract.eventSignatures[fqen]?.emitPayloadSchema?.fields
-		// @ts-ignore
-		const chunkField = payload?.payload?.options?.schema?.fields?.chunk
-		assert.isTruthy(
-			chunkField,
-			'Your event does not conform to the chunking signature. Please add a chunk field to your event payload. Add a field to your payload called chunk: chunkFieldDefinition()'
-		)
-
-		assert.isEqualDeep(
-			chunkField,
-			chunkFieldDefinition(),
-			'Your chunk field is there but not properly formed. Use chunkFieldDefinition() to define it.'
-		)
-	}
-}

package/src/chunkingEmitter/chunkFieldDefinition.ts

@@ -1,12 +0,0 @@
-import { FieldDefinitions } from '@sprucelabs/schema'
-import chunkPagingSchema from '#spruce/schemas/chunkingEmitter/v2023_10_21/chunkPaging.schema'
-
-export function chunkFieldDefinition() {
-	return {
-		type: 'schema',
-		isRequired: true,
-		options: {
-			schema: chunkPagingSchema,
-		},
-	} as FieldDefinitions
-}

package/src/schemas/v2023_10_21/chunkPaging.builder.ts

@@ -1,16 +0,0 @@
-import { buildSchema } from '@sprucelabs/schema'
-
-export default buildSchema({
-	id: 'chunkPaging',
-	name: 'Chunk Paging',
-	fields: {
-		total: {
-			type: 'number',
-			isRequired: true,
-		},
-		current: {
-			type: 'number',
-			isRequired: true,
-		},
-	},
-})

package/tsconfig.dist.json

@@ -1,36 +0,0 @@
-{
-    "compilerOptions": {
-        "module": "es2015",
-        "target": "es6",
-        "lib": [
-            "es2015",
-            "dom"
-        ],
-        "esModuleInterop": true,
-        "moduleResolution": "node",
-        "declaration": true,
-        "noImplicitAny": true,
-        "forceConsistentCasingInFileNames": true,
-        "noImplicitReturns": true,
-        "strict": true,
-        "noUnusedLocals": true,
-        "resolveJsonModule": true,
-        "sourceMap": false,
-        "outDir": "./build",
-        "baseUrl": "src",
-        "experimentalDecorators": true,
-        "skipLibCheck": true,
-		"paths": {
-			"#spruce/*": [".spruce/*"]
-		}
-    },
-    "include": [
-        "./*.ts",
-        "./**/*.ts"
-    ],
-    "exclude": [
-        "**/node_modules/*",
-        "build/*",
-        "esm/*"
-    ]
-}

package/tsconfig.json

@@ -1,40 +0,0 @@
-{
-	"compilerOptions": {
-		"skipLibCheck": true,
-		"module": "commonjs",
-		"esModuleInterop": true,
-		"target": "ES2017",
-		"lib": [
-			"DOM",
-			"es2017",
-			"ES2020"
-		],
-		"declaration": true,
-		"noImplicitAny": true,
-		"allowJs": true,
-		"forceConsistentCasingInFileNames": true,
-		"noImplicitReturns": true,
-		"strict": true,
-		"noUnusedLocals": true,
-		"resolveJsonModule": true,
-		"moduleResolution": "node",
-		"sourceMap": false,
-		"outDir": "build",
-		"baseUrl": "src",
-		"experimentalDecorators": true,
-		"paths": {
-			"#spruce/*": [
-				".spruce/*"
-			]
-		}
-	},
-	"include": [
-		"./src/*.ts",
-		"./src/**/*.ts",
-		"./src/.spruce/**/*"
-	],
-	"exclude": [
-		"build",
-		"esm"
-	]
-}