laravel-workers 0.0.0-stage → 0.4.0

package/kernel/tests/budget.test.mjs

@@ -0,0 +1,527 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { performance } from 'node:perf_hooks';
+
+function stats(samples) {
+  const s = [...samples].sort((a, b) => a - b);
+  const avg = s.reduce((a, b) => a + b, 0) / s.length;
+  const p95 = s[Math.floor(s.length * 0.95)];
+  return { avg, p95 };
+}
+
+test('budget: router/db/validator/scheduler/cache/storage within 5ms p95', async () => {
+  const N = 2000;
+
+  const { normalizeTable: norm, match: mfn } = await import('../router.mjs');
+  const rtTable = norm([{ uri: 'u/{id}', methods: ['GET'] }]);
+  {
+    const a = [];
+    for (let i = 0; i < N; i++) { const t0 = performance.now(); mfn(rtTable, { method: 'GET', path: '/u/' + (i % 50) }); a.push(performance.now() - t0); }
+    const { avg, p95 } = stats(a);
+    assert.ok(avg <= 2, `router avg ${avg}`);
+    assert.ok(p95 <= 5, `router p95 ${p95}`);
+  }
+
+  // The method-not-allowed path (Laravel's automatic OPTIONS response and the
+  // 405): the verbs the URI accepts (the route table scan) + the Allow header.
+  {
+    const { allowedMethods } = await import('../router.mjs');
+    const table2 = norm([
+      { uri: '/posts', methods: ['GET', 'HEAD'] },
+      { uri: '/posts', methods: ['POST'] },
+      { uri: '/posts/{post}', methods: ['GET', 'HEAD', 'PUT', 'DELETE'] },
+    ]);
+    const a = [];
+    for (let i = 0; i < N; i++) {
+      const t0 = performance.now();
+      allowedMethods(table2, { method: 'OPTIONS', path: '/posts' });
+      a.push(performance.now() - t0);
+    }
+    const { avg, p95 } = stats(a);
+    assert.ok(avg <= 2, `allowedMethods avg ${avg}`);
+    assert.ok(p95 <= 5, `allowedMethods p95 ${p95}`);
+  }
+
+  const { table } = await import('../db.mjs');
+  const fake = { prepare: () => ({ bind() { return this; }, async all() { return { results: [] }; } }) };
+  {
+    const a = [];
+    for (let i = 0; i < N; i++) { const t0 = performance.now(); table(fake, 'config').where('k', '=', 'x').toSql(); a.push(performance.now() - t0); }
+    const { avg, p95 } = stats(a);
+    assert.ok(avg <= 2, `db avg ${avg}`);
+    assert.ok(p95 <= 5, `db p95 ${p95}`);
+  }
+
+  const { Validator } = await import('../validator.mjs');
+  {
+    const a = [];
+    for (let i = 0; i < N; i++) { const t0 = performance.now(); const v = new Validator({ email: 'a@b.co' }, { email: 'required|email' }); await v.passes(); a.push(performance.now() - t0); }
+    const { avg, p95 } = stats(a);
+    assert.ok(avg <= 2, `validator avg ${avg}`);
+    assert.ok(p95 <= 5, `validator p95 ${p95}`);
+  }
+
+  // The model attribute read (with the not-compiled guard: a relation or an
+  // accessor is rejected instead of answering null).
+  {
+    const { Model } = await import('../model.mjs');
+    class M extends Model {}
+    M.notCompiled = ['comments', 'notifications'];
+    M.table = 'posts';
+    const m = new M({ id: 1, title: 'x', body: 'y' });
+    const a = [];
+    for (let i = 0; i < N; i++) {
+      const t0 = performance.now();
+      m.get('title');
+      m.get('body');
+      a.push(performance.now() - t0);
+    }
+    const { avg, p95 } = stats(a);
+    assert.ok(avg <= 2, `model get avg ${avg}`);
+    assert.ok(p95 <= 5, `model get p95 ${p95}`);
+  }
+
+  const { defineSchedule } = await import('../scheduler.mjs');
+  const s = defineSchedule(api => { api.call('a', '*/15 * * * *', async () => {}); });
+  const d = new Date('2026-10-18T09:15:00Z');
+  {
+    const a = [];
+    for (let i = 0; i < N; i++) { const t0 = performance.now(); s._match(d, '*/15 * * * *'); a.push(performance.now() - t0); }
+    const { avg, p95 } = stats(a);
+    assert.ok(avg <= 2, `scheduler avg ${avg}`);
+    assert.ok(p95 <= 5, `scheduler p95 ${p95}`);
+  }
+
+  const { createCache } = await import('../cache.mjs');
+  const c = createCache({});
+  await c.put('k', 1, 60000);
+  {
+    const a = [];
+    for (let i = 0; i < N; i++) { const t0 = performance.now(); await c.get('k'); a.push(performance.now() - t0); }
+    const { avg, p95 } = stats(a);
+    assert.ok(avg <= 2, `cache avg ${avg}`);
+    assert.ok(p95 <= 5, `cache p95 ${p95}`);
+  }
+
+  const { createStorage } = await import('../storage.mjs');
+  const st = createStorage({});
+  await st.put('k', 'v');
+  {
+    const a = [];
+    for (let i = 0; i < N; i++) { const t0 = performance.now(); await st.get('k'); a.push(performance.now() - t0); }
+    const { avg, p95 } = stats(a);
+    assert.ok(avg <= 2, `storage avg ${avg}`);
+    assert.ok(p95 <= 5, `storage p95 ${p95}`);
+  }
+
+  // The upload path: the multipart body is parsed and the file is written to
+  // the object store (the D1/R2 round-trip is measured in the shadow harness;
+  // here the store is the in-memory one).
+  {
+    const { buildRequest } = await import('../http.mjs');
+    const { createStorage } = await import('../storage.mjs');
+    const storage = createStorage({});
+    const boundary = '----lwBudgetBoundary';
+    const body =
+      `--${boundary}\r\n` +
+      'Content-Disposition: form-data; name="title"\r\n\r\n' +
+      'budget\r\n' +
+      `--${boundary}\r\n` +
+      'Content-Disposition: form-data; name="avatar"; filename="a.txt"\r\n' +
+      'Content-Type: text/plain\r\n\r\n' +
+      'hello file\r\n' +
+      `--${boundary}--\r\n`;
+    const raw = {
+      method: 'POST',
+      url: 'http://localhost/upload',
+      headers: { 'content-type': `multipart/form-data; boundary=${boundary}` },
+      body: new TextEncoder().encode(body),
+    };
+    const a = [];
+    for (let i = 0; i < N; i++) {
+      const t0 = performance.now();
+      const req = buildRequest(raw, { storage, defaultDisk: 'local' });
+      const file = req.file('avatar');
+      file.getClientOriginalName();
+      file.getSize();
+      await file.storeAs('uploads', 'a.txt');
+      a.push(performance.now() - t0);
+    }
+    const { avg, p95 } = stats(a);
+    assert.ok(avg <= 2, `upload avg ${avg}`);
+    assert.ok(p95 <= 5, `upload p95 ${p95}`);
+  }
+
+  // The event dispatch (the compiled classes): the listeners are called in the
+  // registration order, like Laravel (EVERY listener runs; only an answer of
+  // false stops the chain).
+  {
+    const { buildRt } = await import('../../compiler/runtime/rt-from-context.mjs');
+    const rt = buildRt(
+      {},
+      {
+        http: {},
+        classes: {
+          'App\\Events\\PostPublished': { ctor: (args) => ({ postId: args[0] }), methods: {} },
+          'App\\Listeners\\MarkPostNotified': {
+            ctor: () => ({}),
+            methods: {
+              handle: async function () {
+                this.seen = 1;
+                return null;
+              },
+            },
+          },
+        },
+        eventListeners: { 'App\\Events\\PostPublished': ['App\\Listeners\\MarkPostNotified'] },
+      }
+    );
+    const a = [];
+    for (let i = 0; i < N; i++) {
+      const t0 = performance.now();
+      await rt.event.dispatch(rt.newClass('App\\Events\\PostPublished', [i]));
+      a.push(performance.now() - t0);
+    }
+    const { avg, p95 } = stats(a);
+    assert.ok(avg <= 2, `event dispatch avg ${avg}`);
+    assert.ok(p95 <= 5, `event dispatch p95 ${p95}`);
+  }
+
+  // The mail (a compiled mailable + the kernel mailer): the payload is built
+  // and the mail goes out - the new runtime feature needs its own budget row.
+  {
+    const { buildRt } = await import('../../compiler/runtime/rt-from-context.mjs');
+    const { createMailer } = await import('../mail.mjs');
+    const mailer = createMailer({ transport: 'log', from: 'hello@example.com' });
+    const rt = buildRt(
+      {},
+      {
+        http: { mail: mailer },
+        classes: {
+          'App\\Mail\\OrderMail': {
+            base: 'mailable',
+            ctor: () => ({}),
+            deps: [],
+            methods: {
+              build: async function () {
+                this.subject('Order shipped');
+                this.view('mail.order');
+                this.with({ id: 7 });
+                return this;
+              },
+            },
+          },
+        },
+        views: {
+          'mail.order': { context: {}, main: (r) => { r.echo('<p>Order ' + r.var('id') + '</p>'); } },
+        },
+      }
+    );
+    const a = [];
+    for (let i = 0; i < N; i++) {
+      const t0 = performance.now();
+      const mailable = rt.newClass('App\\Mail\\OrderMail', []);
+      await rt.mail().to('buyer@example.com').send(mailable);
+      a.push(performance.now() - t0);
+    }
+    const { avg, p95 } = stats(a);
+    assert.ok(avg <= 2, `mail avg ${avg}`);
+    assert.ok(p95 <= 5, `mail p95 ${p95}`);
+  }
+
+  // rt.cache() facade (controller-facing Cache::* surface over the D1 store).
+  const { buildRt } = await import('../../compiler/runtime/rt-from-context.mjs');
+  const fakeCache = { async get() { return 1; }, async put() {}, async forget() {} };
+  const rt = buildRt({}, { http: { cache: fakeCache } });
+  {
+    const a = [];
+    for (let i = 0; i < N; i++) { const t0 = performance.now(); rt.cache(); a.push(performance.now() - t0); }
+    const { avg, p95 } = stats(a);
+    assert.ok(avg <= 2, `rt.cache avg ${avg}`);
+    assert.ok(p95 <= 5, `rt.cache p95 ${p95}`);
+  }
+
+  // Eloquent `hashed` cast. The bcrypt work itself is deliberately measured at
+  // cost 4 here; the free-plan cost of the default cost 12 is recorded in
+  // COMPILED.md (measured ~679ms CPU on Workers, matching Laravel).
+  const { Model } = await import('../model.mjs');
+  const { makeSync } = await import('../hash.mjs');
+  class BudgetHashed extends Model {}
+  BudgetHashed.table = 'users';
+  BudgetHashed.casts = { password: 'hashed' };
+  BudgetHashed.hashRounds = 4;
+  const hashed = makeSync('secret', { rounds: 4 });
+  {
+    const m = new BudgetHashed();
+    const a = [];
+    for (let i = 0; i < N; i++) { const t0 = performance.now(); m.set('password', hashed); a.push(performance.now() - t0); }
+    const { avg, p95 } = stats(a);
+    // Already-hashed passthrough is regex-only (no bcrypt); must stay cheap.
+    assert.ok(avg <= 2, `hashed-cast passthrough avg ${avg}`);
+    assert.ok(p95 <= 5, `hashed-cast passthrough p95 ${p95}`);
+  }
+  {
+    const m = new BudgetHashed();
+    const a = [];
+    for (let i = 0; i < 20; i++) { const t0 = performance.now(); m.set('password', 'secret-' + i); a.push(performance.now() - t0); }
+    const { avg, p95 } = stats(a);
+    assert.ok(avg <= 25, `hashed-cast bcrypt cost4 avg ${avg}`);
+    assert.ok(p95 <= 40, `hashed-cast bcrypt cost4 p95 ${p95}`);
+  }
+
+  // The `Hash` facade surface (rt.hash) — the facade call itself is cheap; the
+  // bcrypt work it triggers is the hashed-cast row above.
+  {
+    const a = [];
+    for (let i = 0; i < N; i++) { const t0 = performance.now(); rt.hash.isHashed('x'); a.push(performance.now() - t0); }
+    const { avg, p95 } = stats(a);
+    assert.ok(avg <= 2, `rt.hash avg ${avg}`);
+    assert.ok(p95 <= 5, `rt.hash p95 ${p95}`);
+  }
+
+  // The model write path: rt.db() (the D1 binding) + rt.propSet() (the
+  // `$model->attr = $value` assignment) + Model#set() with the cast applied.
+  {
+    const fakeDb = { prepare: () => ({ bind() { return this; }, async run() { return { changes: 1, lastInsertRowid: 1 }; }, async all() { return { results: [] }; } }) };
+    const rt2 = buildRt({}, { db: fakeDb, hashRounds: 4 });
+    const a = [];
+    for (let i = 0; i < N; i++) {
+      const t0 = performance.now();
+      rt2.db();
+      rt2.propSet(new BudgetHashed(), 'title', 'x');
+      a.push(performance.now() - t0);
+    }
+    const { avg, p95 } = stats(a);
+    assert.ok(avg <= 2, `rt.db+rt.propSet avg ${avg}`);
+    assert.ok(p95 <= 5, `rt.db+rt.propSet p95 ${p95}`);
+  }
+
+  // The `auth.basic` middleware stage: Basic header parse + guard lookup.
+  {
+    const header = 'Basic ' + Buffer.from('a@b.co:secret').toString('base64');
+    const a = [];
+    for (let i = 0; i < N; i++) {
+      const t0 = performance.now();
+      const m = /^\s*Basic\s+(.+)$/i.exec(header);
+      const decoded = atob(m[1].trim());
+      decoded.indexOf(':');
+      a.push(performance.now() - t0);
+    }
+    const { avg, p95 } = stats(a);
+    assert.ok(avg <= 2, `auth.basic header parse avg ${avg}`);
+    assert.ok(p95 <= 5, `auth.basic header parse p95 ${p95}`);
+  }
+
+  // The service adapters (storage/mail/queue) — the *local* part of the call
+  // (the facade lookup + the payload shape). The network cost (R2 / Resend / CF
+  // Queues) is not measurable here; it is a round trip per call.
+  {
+    const { createStorage } = await import('../storage.mjs');
+    const { createMailer } = await import('../mail.mjs');
+    const { createQueue } = await import('../queue.mjs');
+    const storage = createStorage({});
+    const mailer = createMailer({ transport: 'log' });
+    const queue = createQueue({});
+    const a = [];
+    for (let i = 0; i < N; i++) {
+      const t0 = performance.now();
+      await storage.put('k', 'v');
+      await storage.exists('k');
+      await mailer.send({ to: 'a@b.co', subject: 's', text: 't' });
+      await queue.push('default', { i });
+      a.push(performance.now() - t0);
+    }
+    const { avg, p95 } = stats(a);
+    assert.ok(avg <= 2, `services (storage/mail/queue) avg ${avg}`);
+    assert.ok(p95 <= 5, `services (storage/mail/queue) p95 ${p95}`);
+  }
+
+  // The cron evaluation the edge does for the dumped schedule (the Cloudflare
+  // Cron Trigger path): matching a handful of expressions.
+  {
+    const { dueEvents, cronMatches } = await import('../scheduler.mjs');
+    const events = [
+      { name: 'a', expression: '*/5 * * * *' },
+      { name: 'b', expression: '0 9 * * *' },
+      { name: 'c', expression: '0 0 1 * *' },
+    ];
+    const now = new Date('2026-10-18T12:15:00Z');
+    const a = [];
+    for (let i = 0; i < N; i++) {
+      const t0 = performance.now();
+      cronMatches('*/5 * * * *', now);
+      dueEvents(events, now);
+      a.push(performance.now() - t0);
+    }
+    const { avg, p95 } = stats(a);
+    assert.ok(avg <= 2, `schedule cron evaluation avg ${avg}`);
+    assert.ok(p95 <= 5, `schedule cron evaluation p95 ${p95}`);
+  }
+
+  // The `new` expression (the built-in exceptions) + throw_if/throw_unless.
+  {
+    const a = [];
+    for (let i = 0; i < N; i++) {
+      const t0 = performance.now();
+      rt.newError('RuntimeException', 'budget row');
+      rt.throwIf(false, rt.newError('RuntimeException', 'never'));
+      a.push(performance.now() - t0);
+    }
+    const { avg, p95 } = stats(a);
+    assert.ok(avg <= 2, `new exception avg ${avg}`);
+    assert.ok(p95 <= 5, `new exception p95 ${p95}`);
+  }
+
+  // The helper verbs: rt.abortIf/rt.abortUnless/rt.today/rt.log (the request
+  // clock, the platform log) - the local cost only.
+  {
+    const a = [];
+    for (let i = 0; i < N; i++) {
+      const t0 = performance.now();
+      rt.abortIf(false, 404, 'never');
+      rt.abortUnless(true, 500, 'never');
+      rt.today().toDateString();
+      rt.log('info', 'budget row');
+      a.push(performance.now() - t0);
+    }
+    const { avg, p95 } = stats(a);
+    assert.ok(avg <= 2, `helper verbs avg ${avg}`);
+    assert.ok(p95 <= 5, `helper verbs p95 ${p95}`);
+  }
+
+  // The helper surface: rt.back/rt.dataGet/rt.tap/rt.report/rt.env.
+  {
+    const a = [];
+    for (let i = 0; i < N; i++) {
+      const t0 = performance.now();
+      rt.back('/fallback');
+      rt.dataGet({ a: { b: 1 } }, 'a.b');
+      rt.tap('v', () => {});
+      rt.report(new Error('budget row'));
+      rt.env('APP_ENV');
+      a.push(performance.now() - t0);
+    }
+    const { avg, p95 } = stats(a);
+    assert.ok(avg <= 2, `helper surface avg ${avg}`);
+    assert.ok(p95 <= 5, `helper surface p95 ${p95}`);
+  }
+
+  // The Gate check (rt.gate): the local cost of a policy decision (the
+  // registry lookup, the guest rule, the compiled policy call). The policy
+  // itself is compiled - there is no PHP at the edge.
+  {
+    const policies = {
+      'App\\Models\\Post': {
+        policy: 'App\\Policies\\PostPolicy',
+        before: null,
+        methods: {
+          update: {
+            guest: false,
+            fn: async (rt, v_user, v_post) =>
+              rt.strictEq(rt.prop(v_user, 'id'), rt.prop(v_post, 'user_id'), false, false),
+          },
+        },
+      },
+    };
+    const rt3 = buildRt({}, { http: { auth: { user: async () => ({ id: 1 }) } }, policies });
+    const post = { user_id: 1 };
+    const a = [];
+    for (let i = 0; i < N; i++) {
+      const t0 = performance.now();
+      await rt3.gate('update', post, 'App\\Models\\Post', false);
+      a.push(performance.now() - t0);
+    }
+    const { avg, p95 } = stats(a);
+    assert.ok(avg <= 2, `rt.gate avg ${avg}`);
+    assert.ok(p95 <= 5, `rt.gate p95 ${p95}`);
+  }
+
+  // The paginator (the LengthAwarePaginator): the local cost of the pages and
+  // the URLs (the query string + the URL window). The D1 round trips (the
+  // count + the page) are not measurable here.
+  {
+    const { LengthAwarePaginator } = await import('../paginator.mjs');
+    const items = [{ id: 1 }, { id: 2 }];
+    const a = [];
+    for (let i = 0; i < N; i++) {
+      const t0 = performance.now();
+      const p = new LengthAwarePaginator(items, 60, 2, 10, { path: 'http://localhost/posts' });
+      p.total();
+      p.currentPage();
+      p.nextPageUrl();
+      p.elements();
+      a.push(performance.now() - t0);
+    }
+    const { avg, p95 } = stats(a);
+    assert.ok(avg <= 2, `paginator avg ${avg}`);
+    assert.ok(p95 <= 5, `paginator p95 ${p95}`);
+  }
+
+  // The translation helper (__()): the local cost of the lookup (the dumped
+  // strings) + the place-holder replacements.
+  {
+    const rt4 = buildRt(
+      {},
+      {
+        config: {
+          'app.locale': 'en',
+          'app.fallback_locale': 'en',
+          translations: { en: { pagination: { previous: '&laquo; Previous' } } },
+        },
+      }
+    );
+    const a = [];
+    for (let i = 0; i < N; i++) {
+      const t0 = performance.now();
+      rt4.__('pagination.previous');
+      rt4.__('Go to page :page', { page: i });
+      a.push(performance.now() - t0);
+    }
+    const { avg, p95 } = stats(a);
+    assert.ok(avg <= 2, `rt.__ avg ${avg}`);
+    assert.ok(p95 <= 5, `rt.__ p95 ${p95}`);
+  }
+
+  // The D1 blob store (the Storage facade on D1 - no R2, no card): the local
+  // part of one put + one get (the SQL text, the size check, the row shape).
+  // The D1 round trip itself is not measurable here; on the free plan a blob
+  // write counts as one D1 row write and a blob read as one row read
+  // (100k writes/day, 5M reads/day).
+  {
+    const rows = new Map();
+    const fakeD1 = {
+      prepare(sql) {
+        const stmt = {
+          params: [],
+          bind(...p) { this.params = p; return this; },
+          async first() {
+            if (/SELECT 1/.test(sql)) return { '1': 1 };
+            const row = rows.get(this.params[0]);
+            return row === undefined ? null : { body: row.body };
+          },
+          async run() {
+            if (/^INSERT OR REPLACE/.test(sql)) {
+              rows.set(this.params[0], { body: this.params[1] });
+              return { success: true, meta: { changes: 1 } };
+            }
+            return { success: true };
+          },
+        };
+        return stmt;
+      },
+    };
+    const { createStorage: createStore } = await import('../storage.mjs');
+    const blob = createStore({ d1: fakeD1 });
+    await blob.put('k', 'v');
+    const a = [];
+    for (let i = 0; i < N; i++) {
+      const t0 = performance.now();
+      await blob.put('k', 'v');
+      await blob.get('k');
+      a.push(performance.now() - t0);
+    }
+    const { avg, p95 } = stats(a);
+    assert.ok(avg <= 2, `storage d1 blob store avg ${avg}`);
+    assert.ok(p95 <= 5, `storage d1 blob store p95 ${p95}`);
+  }
+});