wabe 0.6.9 → 0.6.11

package/src/cache/InMemoryCache.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it, beforeEach, spyOn } from 'bun:test'
+import { InMemoryCache } from './InMemoryCache'
+
+describe('InMemoryCache', () => {
+	const inMemoryCache = new InMemoryCache({
+		interval: 100,
+	})
+
+	beforeEach(() => {
+		inMemoryCache.clear()
+	})
+
+	it('should init a InMemoryCache', () => {
+		const spySetInterval = spyOn(global, 'setInterval')
+		const spyClearInterval = spyOn(global, 'clearInterval')
+
+		const store = new InMemoryCache({ interval: 100 })
+
+		store.stop()
+
+		expect(spySetInterval).toHaveBeenCalledTimes(1)
+		expect(spySetInterval).toHaveBeenCalledWith(expect.any(Function), 100)
+		expect(spyClearInterval).toHaveBeenCalledTimes(1)
+		expect(spyClearInterval).toHaveBeenCalledWith(store.intervalId)
+	})
+
+	it('should store a value', () => {
+		inMemoryCache.set('key', 'value')
+
+		expect(inMemoryCache.get('key')).toBe('value')
+	})
+
+	it('should clear an in memory cache', () => {
+		inMemoryCache.set('key', 'value')
+
+		expect(inMemoryCache.get('key')).toBe('value')
+
+		inMemoryCache.clear()
+
+		expect(inMemoryCache.get('key')).toBeUndefined()
+	})
+
+	it('should return undefined if the key does not exist', () => {
+		expect(inMemoryCache.get('key2')).toBeUndefined()
+	})
+
+	it('should clear a cache after timeLimit', () => {
+		const localInMemoryCache = new InMemoryCache({
+			interval: 100,
+		})
+
+		localInMemoryCache.set('key', 'value')
+
+		setTimeout(() => {
+			expect(localInMemoryCache.get('key')).not.toBeUndefined()
+		}, 50)
+
+		setTimeout(() => {
+			expect(localInMemoryCache.get('key')).toBeUndefined()
+		}, 100)
+	})
+})

package/src/cache/InMemoryCache.ts

@@ -0,0 +1,45 @@
+export interface InMemoryCacheOptions {
+	/**
+	 * Interval in ms to clear the cache
+	 */
+	interval: number
+}
+
+/**
+ * InMemoryCache is a class that stores data for a certain amount of time
+ */
+export class InMemoryCache<T> {
+	private options: InMemoryCacheOptions
+	private store: Record<string, any>
+
+	public intervalId: Timer | undefined = undefined
+
+	constructor(options: InMemoryCacheOptions) {
+		this.options = options
+		this.store = {}
+
+		this._init()
+	}
+
+	_init() {
+		this.intervalId = setInterval(() => {
+			this.clear()
+		}, this.options.interval)
+	}
+
+	set(key: string, value: T) {
+		this.store[key] = value
+	}
+
+	get(key: string): T | undefined {
+		return this.store[key]
+	}
+
+	clear() {
+		this.store = {}
+	}
+
+	stop() {
+		clearInterval(this.intervalId)
+	}
+}

package/src/cron/index.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it, mock } from 'bun:test'
+import { cron } from '.'
+
+describe('cron', () => {
+	it('should run the function', () => {
+		const run = mock()
+
+		const job = cron({
+			pattern: '* * * * * *',
+			run,
+		})({} as any)
+
+		job.trigger()
+
+		expect(run).toHaveBeenCalledTimes(1)
+	})
+})

package/src/cron/index.ts

@@ -0,0 +1,43 @@
+import { Cron } from 'croner'
+import type { Wabe, WabeTypes } from '../server'
+
+export type OutputCron<T extends WabeTypes> = (wabe: Wabe<T>) => Cron
+
+export const cron =
+	<T extends WabeTypes>({
+		pattern,
+		run,
+		maxRuns,
+		enabledProtectedRuns,
+	}: {
+		pattern: string
+		maxRuns?: number
+		enabledProtectedRuns?: boolean
+		run: (wabe: Wabe<T>) => any | Promise<any>
+	}): OutputCron<T> =>
+	(wabe: Wabe<T>) =>
+		new Cron(pattern, { maxRuns, protect: enabledProtectedRuns }, () => run(wabe))
+
+export enum CronExpressions {
+	EVERY_SECOND = '* * * * * *',
+	EVERY_MINUTE = '0 * * * * *',
+	EVERY_HOUR = '0 0 * * * *',
+	EVERY_DAY_AT_MIDNIGHT = '0 0 0 * * *',
+	EVERY_WEEK = '0 0 0 * * 0',
+	EVERY_YEAR = '0 0 0 1 1 *',
+	WEEKDAYS_MORNING = '0 0 7 * * 1-5', // Every weekday at 7 AM
+	WEEKENDS_EVENING = '0 0 19 * * 6-7', // Every weekend at 7 PM
+	FIRST_DAY_OF_MONTH = '0 0 0 1 * *',
+	LAST_DAY_OF_MONTH = '0 0 0 L * *', // L stands for the last day of the month
+	EVERY_15_MINUTES = '0 */15 * * * *',
+	EVERY_30_MINUTES = '0 */30 * * * *',
+	EVERY_2_HOURS = '0 0 */2 * * *',
+	EVERY_6_HOURS = '0 0 */6 * * *',
+	EVERY_12_HOURS = '0 0 */12 * * *',
+}
+
+export type CronConfig<T extends WabeTypes> = Array<{
+	name: string
+	cron: OutputCron<T>
+	job?: Cron
+}>