@substrat-run/contract-tests 0.120.0 → 0.122.0

package/dist/scope-host-suite.js

@@ -1127,6 +1127,42 @@ export function scopeHostContractSuite(adapterName, makeFixture, opts = {}) {
             await expect(host.admin.markEventsDrained(staff, t2, sDrain, [])).rejects.toThrow(/unknown scope/);
             await expect(host.admin.markEventsDrained(staff, t1, scopeId.parse(ulid()), [])).rejects.toThrow(/unknown scope/);
         });
+        it('stamps and reopens more events than a Durable Object binds parameters (#1776)', async () => {
+            // A DO's SQLite refuses the 101st bound parameter (#1741), and the drain batch is 200
+            // by default. A statement binding one `?` per event id therefore failed every default
+            // drain of a busy scope on the hosted host, while node, which allows far more, stayed
+            // green. Its own scope, so the counts below are this test's events and nothing else.
+            const sBig = scopeId.parse(ulid());
+            await host.provisionScope(staff, { tenantId: t1, scopeId: sBig, vertical: 'connector-vertical' });
+            await host.admin.activateScope(staff, t1, sBig);
+            const stub = await host.getScope(alice, t1, sBig);
+            await stub.invoke('test/emit-burst', { entityId: ulid(), count: 350 });
+            const pending = await host.admin.readUndrainedEvents(staff, t1, sBig, 1000);
+            expect(pending).toHaveLength(350);
+            const ids = pending.map((e) => e.id);
+            // 150: past the limit. Then 200, the default batch, overlapping the first so the
+            // count has to tell a stamped row from an unstamped one inside one oversized list.
+            await expect(host.admin.markEventsDrained(staff, t1, sBig, ids.slice(0, 150))).resolves.toBe(150);
+            // The two batches must carry different instants for the reopen below to tell them apart.
+            const firstMarked = Date.now();
+            while (Date.now() <= firstMarked + 1)
+                await new Promise((r) => setTimeout(r, 1));
+            await expect(host.admin.markEventsDrained(staff, t1, sBig, ids.slice(100, 350))).resolves.toBe(200);
+            await expect(host.admin.readUndrainedEvents(staff, t1, sBig, 1000)).resolves.toHaveLength(0);
+            const stamps = (await host.admin.auditLog(staff, { tenantId: t1 }))
+                .filter((r) => r.action === 'drainEvents' && r.scopeId === sBig)
+                .map((r) => r.after)
+                .sort((a, b) => (a.drainedAt < b.drainedAt ? -1 : 1));
+            expect(stamps.map((s) => [s.drained, s.requested])).toEqual([[150, 150], [200, 250]]);
+            // The reopen, past the limit the same way. Just after the FIRST instant it reopens exactly
+            // the first 150, which is what shows the overlap kept its first stamp: a stamp that
+            // re-marked rows 100–149 would have moved them out of this window.
+            const justAfter = (at) => new Date(Date.parse(at) + 1).toISOString();
+            await expect(host.admin.redrainEvents(staff, t1, sBig, { drainedBefore: justAfter(stamps[0].drainedAt) })).resolves.toBe(150);
+            expect((await host.admin.readUndrainedEvents(staff, t1, sBig, 1000)).map((e) => e.id)).toEqual(ids.slice(0, 150));
+            await expect(host.admin.redrainEvents(staff, t1, sBig, { drainedBefore: justAfter(stamps[1].drainedAt) })).resolves.toBe(200);
+            expect((await host.admin.readUndrainedEvents(staff, t1, sBig, 1000)).map((e) => e.id)).toEqual(ids);
+        });
         it('facets the outbox, and keeps an ERASED payload out of the null bucket (#1239)', async () => {
             const stub = await host.getScope(alice, t1, s1);
             const subject = ulid();
@@ -4165,6 +4201,7 @@ export function scopeHostContractSuite(adapterName, makeFixture, opts = {}) {
             await expectRefusal(host.admin.promoteVersion(staff, 'callout', 'prod', ghost), 'not_found');
             await expectRefusal(host.admin.bindScopeVersion(staff, t1, s1, ghost), 'not_found');
             await expectRefusal(host.admin.versionManifest(staff, 'callout', ghost), 'not_found');
+            await expectRefusal(host.admin.versionMigrations(staff, 'callout', ghost), 'not_found');
             // versionManifest refuses on the PAIR — `!v || v.vertical_slug !== verticalSlug` —
             // so the absent id above only exercises HALF its guard. A version that really
             // exists, under a DIFFERENT vertical, must read as absent too: asking for it under
@@ -4191,6 +4228,56 @@ export function scopeHostContractSuite(adapterName, makeFixture, opts = {}) {
             // firing, not the version failing to exist.
             await host.admin.versionManifest(staff, 'otherowner', elsewhere);
             await expectRefusal(host.admin.versionManifest(staff, 'callout', elsewhere), 'not_found');
+            // The migrations read refuses on the same pair: a version's SQL describes its schema.
+            await host.admin.versionMigrations(staff, 'otherowner', elsewhere);
+            await expectRefusal(host.admin.versionMigrations(staff, 'callout', elsewhere), 'not_found');
+        });
+        it('stores a version\'s SQL migrations apart from its manifest, and never reads absent as none (#1764)', async () => {
+            await host.admin.registerVertical(staff, { slug: 'migrationsapart', name: 'Apart', source: 'builtin' });
+            const base = {
+                version: '1.0.0',
+                entry: 'index.js',
+                registry: { permissions: [], roles: [], entityGrants: [] },
+                digests: { manifest: 'm', permission: 'p', migration: 'g' },
+            };
+            const publish = async (manifest) => {
+                const id = ulid();
+                await host.admin.publishVersion(staff, {
+                    id, verticalSlug: 'migrationsapart', version: `1.0.${id.toLowerCase()}`, manifestDigest: 'm',
+                    permissionDigest: 'p', migrationDigest: 'g', deploymentRef: null,
+                    manifestJson: typeof manifest === 'string' ? manifest : JSON.stringify(manifest),
+                });
+                return id;
+            };
+            const migrations = [
+                { moduleId: 'engine-workorder', version: '0001-init', sql: 'CREATE TABLE a (id TEXT);' },
+                { moduleId: 'helpdesk', version: '0001-init', sql: 'CREATE TABLE b (id TEXT);' },
+                { moduleId: 'helpdesk', version: '0002-more', sql: 'ALTER TABLE b ADD COLUMN c TEXT;' },
+            ];
+            // Carried: every migration, in the order the host runs them, and a manifest without them.
+            const carried = await publish({ ...base, migrations });
+            expect(await host.admin.versionMigrations(staff, 'migrationsapart', carried)).toEqual(migrations);
+            const manifest = JSON.parse((await host.admin.versionManifest(staff, 'migrationsapart', carried)));
+            expect(manifest).not.toHaveProperty('migrations');
+            expect(manifest).toEqual(base);
+            // `[]` is a version whose modules ship none; an absent field is one that cannot say.
+            expect(await host.admin.versionMigrations(staff, 'migrationsapart', await publish({ ...base, migrations: [] }))).toEqual([]);
+            expect(await host.admin.versionMigrations(staff, 'migrationsapart', await publish(base))).toBeNull();
+            // Over the push's caps, or not shaped like migrations: dropped, and read as not available.
+            // `/deploy` refuses such a set before the upload; this is the cap on whatever else reaches
+            // `publishVersion` (the raw `POST …/versions`, #1765), and the publish still succeeds.
+            const overCap = await publish({
+                ...base,
+                migrations: [{ moduleId: 'helpdesk', version: '0001', sql: 'x'.repeat(512 * 1024 + 1) }],
+            });
+            expect(await host.admin.versionMigrations(staff, 'migrationsapart', overCap)).toBeNull();
+            expect(JSON.parse((await host.admin.versionManifest(staff, 'migrationsapart', overCap)))).not.toHaveProperty('migrations');
+            const malformed = await publish({ ...base, migrations: 'nope' });
+            expect(await host.admin.versionMigrations(staff, 'migrationsapart', malformed)).toBeNull();
+            // A manifest that is not JSON, or none at all: stored as it came, with no SQL to show.
+            const junk = await publish('not json');
+            expect(await host.admin.versionManifest(staff, 'migrationsapart', junk)).toBe('not json');
+            expect(await host.admin.versionMigrations(staff, 'migrationsapart', junk)).toBeNull();
         });
         it('an archived scope blocks the delete naming the reap step; a reaped tombstone never blocks', async () => {
             // A deleted app leaves an `archived` row (restorable via unarchive), then a
@@ -5805,6 +5892,13 @@ export function scopeHostContractSuite(adapterName, makeFixture, opts = {}) {
             // An empty status list means "no status is acceptable" — it must match
             // nothing, never degenerate into an unfiltered read of the whole fleet.
             expect(await host.admin.listScopes(staff, { tenantId: t5, status: [] })).toEqual([]);
+            // A list longer than a Durable Object binds parameters (#1776). Nothing bounds its
+            // length, since a status may repeat, and a `?` per entry was refused past 100.
+            const repeated = await host.admin.listScopes(staff, {
+                tenantId: t5,
+                status: [...Array(150).fill('active'), 'suspended'],
+            });
+            expect(repeated.map((s) => s.id)).toEqual(both.map((s) => s.id));
             await host.admin.unsuspendScope(staff, t5, target.id);
         });
         it('lists the whole fleet across tenants when unfiltered (§4.5)', async () => {
@@ -5865,6 +5959,13 @@ export function scopeHostContractSuite(adapterName, makeFixture, opts = {}) {
             expect(provisions.every((r) => r.action === 'provisionScope')).toBe(true);
             // Empty action list matches nothing rather than everything.
             expect(await host.admin.auditLog(staff, { tenantId: t5, action: [] })).toEqual([]);
+            // A list longer than a Durable Object binds parameters (#1776): an action may repeat,
+            // so nothing bounds its length, and a `?` per entry was refused past 100.
+            const repeated = await host.admin.auditLog(staff, {
+                tenantId: t5,
+                action: [...Array(150).fill('suspendScope'), 'unsuspendScope'],
+            });
+            expect(repeated.map((r) => r.id)).toEqual(lifecycle.map((r) => r.id));
         });
         it('orders oldest-first by default and newest-first on request (§4.5)', async () => {
             const asc = await host.admin.auditLog(staff, { tenantId: t5 });