@20syldev/api 4.7.0 → 4.8.0

package/tests/integration/api.test.ts

@@ -331,6 +331,19 @@ describe('GET /v4/time', () => {
         assert.ok(ts >= new Date('2020-01-01').getTime());
         assert.ok(ts <= new Date('2020-12-31').getTime());
     });
+
+    test('countdown future returns direction and remaining', async () => {
+        const future = new Date(Date.now() + 10 * 24 * 3600 * 1000).toISOString();
+        const { status, body } = await getJson(`/v4/time?type=countdown&target=${encodeURIComponent(future)}`);
+        assert.equal(status, 200);
+        assert.equal(body.direction, 'future');
+        assert.ok(typeof body.human === 'string');
+    });
+
+    test('countdown missing target returns 400', async () => {
+        const { status } = await getJson('/v4/time?type=countdown');
+        assert.equal(status, 400);
+    });
 });
 
 describe('GET /v4/username', () => {
@@ -697,6 +710,49 @@ describe('GET /v4/password', () => {
     });
 });
 
+describe('GET /v4/cron', () => {
+    test('returns next dates for * * * * *', async () => {
+        const { status, body } = await getJson('/v4/cron?expr=*%20*%20*%20*%20*');
+        assert.equal(status, 200);
+        assert.equal((body.next as string[]).length, 5);
+        assert.ok(typeof body.description === 'string');
+    });
+
+    test('count param is respected', async () => {
+        const { body } = await getJson('/v4/cron?expr=*%20*%20*%20*%20*&count=3');
+        assert.equal((body.next as string[]).length, 3);
+    });
+
+    test('invalid expression returns 400', async () => {
+        const { status } = await getJson('/v4/cron?expr=invalid');
+        assert.equal(status, 400);
+    });
+
+    test('missing expr returns 400', async () => {
+        const { status } = await getJson('/v4/cron');
+        assert.equal(status, 400);
+    });
+});
+
+describe('GET /v4/regex', () => {
+    test('basic match returns count and matches', async () => {
+        const { status, body } = await getJson('/v4/regex?pattern=hello&text=hello%20world');
+        assert.equal(status, 200);
+        assert.equal(body.valid, true);
+        assert.ok((body.count as number) >= 1);
+    });
+
+    test('invalid pattern returns valid: false with 200', async () => {
+        const { status, body } = await getJson('/v4/regex?pattern=%5Binvalid&text=hello');
+        assert.equal(status, 200);
+        assert.equal(body.valid, false);
+    });
+
+    test('missing pattern returns 400', async () => {
+        const { status } = await getJson('/v4/regex?text=hello');
+        assert.equal(status, 400);
+    });
+});
 
 describe('Prototype access on dynamic endpoints', () => {
     test('algorithms?method=toString returns 400', async () => {

package/tests/unit/cron.test.ts

@@ -0,0 +1,110 @@
+import { strict as assert } from 'node:assert';
+import { describe, test } from 'node:test';
+
+import cron from '../../src/modules/v4/cron.js';
+
+// Fixed reference point: a known Monday at 08:45 UTC
+const FROM = '2026-01-05T08:45:00Z'; // Monday
+
+describe('cron', () => {
+    describe('every minute', () => {
+        test('* * * * * returns 5 consecutive minutes', () => {
+            const r = cron('* * * * *', 5, FROM);
+            assert.equal(r.next.length, 5);
+            // First result should be the next minute after FROM
+            assert.ok(r.next[0]!.startsWith('2026-01-05T08:46'));
+        });
+
+        test('description is "Every minute"', () => {
+            const r = cron('* * * * *', 1, FROM);
+            assert.equal(r.description, 'Every minute');
+        });
+    });
+
+    describe('every N minutes', () => {
+        test('*/15 * * * * returns results 15 minutes apart', () => {
+            const r = cron('*/15 * * * *', 3, FROM);
+            assert.equal(r.next.length, 3);
+            assert.ok(r.next[0]!.includes('T09:00'));
+            assert.ok(r.next[1]!.includes('T09:15'));
+            assert.ok(r.next[2]!.includes('T09:30'));
+        });
+
+        test('description mentions every 15 minutes', () => {
+            const r = cron('*/15 * * * *', 1, FROM);
+            assert.match(r.description, /Every 15 minutes/);
+        });
+    });
+
+    describe('at fixed time', () => {
+        test('0 9 * * 1-5 fires at 09:00 on weekdays', () => {
+            const r = cron('0 9 * * 1-5', 3, FROM);
+            // Next Monday 09:00 is same day
+            assert.ok(r.next[0]!.includes('T09:00'));
+            // All results should be on weekdays (Mon–Fri)
+            for (const date of r.next) {
+                const d = new Date(date);
+                const dow = d.getUTCDay();
+                assert.ok(dow >= 1 && dow <= 5, `Expected weekday, got ${dow}`);
+            }
+        });
+
+        test('description includes Monday through Friday', () => {
+            const r = cron('0 9 * * 1-5', 1, FROM);
+            assert.match(r.description, /Monday through Friday/);
+        });
+    });
+
+    describe('plan example', () => {
+        test('*/15 9-17 * * 1-5 fires between 09:00 and 17:45 on weekdays', () => {
+            const r = cron('*/15 9-17 * * 1-5', 5, FROM);
+            assert.equal(r.next.length, 5);
+            for (const date of r.next) {
+                const d = new Date(date);
+                const hour = d.getUTCHours();
+                assert.ok(hour >= 9 && hour <= 17);
+                const dow = d.getUTCDay();
+                assert.ok(dow >= 1 && dow <= 5);
+            }
+        });
+
+        test('description includes "Every 15 minutes"', () => {
+            const r = cron('*/15 9-17 * * 1-5', 1, FROM);
+            assert.match(r.description, /Every 15 minutes/);
+        });
+    });
+
+    describe('count', () => {
+        test('count=10 returns 10 results', () => {
+            const r = cron('* * * * *', 10, FROM);
+            assert.equal(r.next.length, 10);
+        });
+
+        test('count=1 returns 1 result', () => {
+            const r = cron('*/30 * * * *', 1, FROM);
+            assert.equal(r.next.length, 1);
+        });
+    });
+
+    describe('errors', () => {
+        test('missing expr throws', () => {
+            assert.throws(() => cron(''), /expression/);
+        });
+
+        test('too few fields throws', () => {
+            assert.throws(() => cron('* * * *'), /5 fields/);
+        });
+
+        test('invalid range throws', () => {
+            assert.throws(() => cron('60-70 * * * *'), /valid: 0-59/);
+        });
+
+        test('invalid timezone throws', () => {
+            assert.throws(() => cron('* * * * *', 5, undefined, 'Mars/Olympus'), /timezone/);
+        });
+
+        test('count out of range throws', () => {
+            assert.throws(() => cron('* * * * *', 21), /Count/);
+        });
+    });
+});

package/tests/unit/regex.test.ts

@@ -0,0 +1,95 @@
+import { strict as assert } from 'node:assert';
+import { describe, test } from 'node:test';
+
+import regex from '../../src/modules/v4/regex.js';
+
+describe('regex', () => {
+    describe('basic matching', () => {
+        test('finds a simple match', () => {
+            const r = regex('hello', 'hello world');
+            assert.equal(r.valid, true);
+            assert.equal(r.count, 1);
+            assert.equal(r.matches[0]!.match, 'hello');
+            assert.equal(r.matches[0]!.index, 0);
+        });
+
+        test('finds multiple matches', () => {
+            const r = regex('\\d+', 'abc 42 def 7');
+            assert.equal(r.count, 2);
+            assert.equal(r.matches[0]!.match, '42');
+            assert.equal(r.matches[1]!.match, '7');
+        });
+
+        test('no match returns empty array', () => {
+            const r = regex('xyz', 'hello world');
+            assert.equal(r.valid, true);
+            assert.equal(r.count, 0);
+            assert.deepEqual(r.matches, []);
+        });
+    });
+
+    describe('flags', () => {
+        test('flag i enables case-insensitive matching', () => {
+            const r = regex('hello', 'HELLO world', 'i');
+            assert.equal(r.count, 1);
+            assert.equal(r.matches[0]!.match, 'HELLO');
+        });
+
+        test('invalid flag x is silently ignored', () => {
+            const r = regex('hello', 'hello world', 'x');
+            assert.equal(r.valid, true);
+            assert.equal(r.count, 1);
+        });
+
+        test('g flag is always present', () => {
+            const r = regex('a', 'aaa', '');
+            assert.ok(r.flags.includes('g'));
+        });
+    });
+
+    describe('capture groups', () => {
+        test('numbered groups are returned', () => {
+            const r = regex('(\\d{4})-(\\d{2})', '2026-05');
+            assert.deepEqual(r.matches[0]!.groups, ['2026', '05']);
+        });
+
+        test('named groups are returned', () => {
+            const r = regex('(?<year>\\d{4})-(?<month>\\d{2})', '2026-05');
+            assert.equal(r.matches[0]!.namedGroups.year, '2026');
+            assert.equal(r.matches[0]!.namedGroups.month, '05');
+        });
+
+        test('no groups returns empty arrays', () => {
+            const r = regex('hello', 'hello');
+            assert.deepEqual(r.matches[0]!.groups, []);
+            assert.deepEqual(r.matches[0]!.namedGroups, {});
+        });
+    });
+
+    describe('invalid pattern', () => {
+        test('invalid regex returns valid: false', () => {
+            const r = regex('[invalid', 'hello');
+            assert.equal(r.valid, false);
+            assert.equal(r.count, 0);
+            assert.deepEqual(r.matches, []);
+        });
+    });
+
+    describe('errors', () => {
+        test('missing pattern throws', () => {
+            assert.throws(() => regex('', 'hello'), /pattern/);
+        });
+
+        test('missing text throws', () => {
+            assert.throws(() => regex('hello', ''), /text/);
+        });
+
+        test('pattern too long throws', () => {
+            assert.throws(() => regex('a'.repeat(201), 'hello'), /200/);
+        });
+
+        test('text too long throws', () => {
+            assert.throws(() => regex('hello', 'a'.repeat(1001)), /1000/);
+        });
+    });
+});

package/tests/unit/time.test.ts

@@ -65,4 +65,51 @@ describe('time', () => {
         const result = time('live', undefined, undefined, undefined, 'Europe/Paris');
         assert.equal(result.timezone, 'Europe/Paris');
     });
+
+    describe('countdown', () => {
+        test('future date returns direction future', () => {
+            const future = new Date(Date.now() + 7 * 24 * 3600 * 1000).toISOString();
+            const r = time('countdown', undefined, undefined, undefined, undefined, future);
+            assert.equal(r.direction, 'future');
+        });
+
+        test('past date returns direction past', () => {
+            const past = new Date(Date.now() - 7 * 24 * 3600 * 1000).toISOString();
+            const r = time('countdown', undefined, undefined, undefined, undefined, past);
+            assert.equal(r.direction, 'past');
+        });
+
+        test('remaining breakdown is correct', () => {
+            const target = new Date(Date.now() + 2 * 86400 * 1000 + 3 * 3600 * 1000).toISOString();
+            const r = time('countdown', undefined, undefined, undefined, undefined, target);
+            const rem = r.remaining as { days: number; hours: number };
+            assert.equal(rem.days, 2);
+            assert.equal(rem.hours, 3);
+        });
+
+        test('human skips zero units', () => {
+            const target = new Date(Date.now() + 3 * 86400 * 1000).toISOString();
+            const r = time('countdown', undefined, undefined, undefined, undefined, target);
+            assert.ok(!(r.human as string).includes('hour'));
+            assert.ok(!(r.human as string).includes('minute'));
+        });
+
+        test('throws on missing target', () => {
+            assert.throws(() => time('countdown'), /target date/);
+        });
+
+        test('throws on invalid target', () => {
+            assert.throws(
+                () => time('countdown', undefined, undefined, undefined, undefined, 'not-a-date'),
+                /valid target date/,
+            );
+        });
+
+        test('throws if target is more than 100 years away', () => {
+            assert.throws(
+                () => time('countdown', undefined, undefined, undefined, undefined, '2200-01-01'),
+                /100 years/,
+            );
+        });
+    });
 });