@taodigital/app-brain 0.0.0-stage → 1.2.1

package/src/archetype-classification.ts

@@ -0,0 +1,132 @@
+/**
+ * Screen-archetype classification + KAG journey-pair suggestion — pure logic,
+ * no I/O, unit-testable in isolation (same shape as orphan-classification.ts).
+ *
+ * Rule-based rather than LLM-based on purpose: this only needs to look at
+ * data already captured during crawl (Element.role/expectedData, Screen.url/
+ * name), so it works with zero LLM provider configured and costs nothing to
+ * run on every project. It is deliberately coarse — good enough to rank
+ * "which screen pairs are worth generating a KAG journey test for" so a user
+ * doesn't have to already know both screen ids, not a general-purpose UI
+ * classifier.
+ */
+
+export type ScreenArchetype = 'LOGIN' | 'SIGNUP' | 'SEARCH' | 'CHECKOUT' | 'FORM' | 'GENERIC';
+
+export interface ClassifiableElement {
+  role: string | null;
+  expectedData: string | null;
+}
+
+export interface ClassifiableScreen {
+  id: string;
+  name: string;
+  url: string | null;
+}
+
+export interface ArchetypeResult {
+  archetype: ScreenArchetype;
+  reason: string;
+}
+
+const LOGIN_URL_RE = /login|signin|sign-in/i;
+const SIGNUP_URL_RE = /signup|sign-up|register|onboard/i;
+const CHECKOUT_URL_RE = /checkout|cart|basket/i;
+// Element.role values observed at crawl time (crawler.ts) are lowercase HTML
+// input types or tag/aria names — see that file for exactly how they're set.
+const FORM_FIELD_ROLES = new Set(['text', 'email', 'tel', 'number', 'date', 'textarea', 'select']);
+
+/** Classifies a single screen from its URL/name and the elements crawled on it.
+ *  Checked in priority order — the first matching, most specific signal wins,
+ *  since e.g. a checkout page often also has a form field or two. */
+export function classifyScreenArchetype(
+  screen: ClassifiableScreen,
+  elements: ClassifiableElement[],
+): ArchetypeResult {
+  const hasPassword = elements.some((e) => e.role === 'password' || e.expectedData === 'password');
+  const hasEmail = elements.some((e) => e.role === 'email' || e.expectedData === 'valid_email');
+  const hasSearch = elements.some((e) => e.role === 'search' || e.expectedData === 'search_term');
+  const urlOrName = `${screen.url ?? ''} ${screen.name ?? ''}`;
+
+  if (CHECKOUT_URL_RE.test(urlOrName)) {
+    return { archetype: 'CHECKOUT', reason: "URL/name matches checkout/cart/basket" };
+  }
+  if (SIGNUP_URL_RE.test(urlOrName) && hasEmail && hasPassword) {
+    return { archetype: 'SIGNUP', reason: 'URL/name matches signup/register, with email + password fields present' };
+  }
+  if (hasPassword) {
+    return { archetype: 'LOGIN', reason: 'Has a password-type input element' };
+  }
+  if (LOGIN_URL_RE.test(urlOrName)) {
+    return { archetype: 'LOGIN', reason: 'URL/name matches login/signin' };
+  }
+  if (hasSearch) {
+    return { archetype: 'SEARCH', reason: 'Has a search-type input element' };
+  }
+  if (elements.some((e) => e.role && FORM_FIELD_ROLES.has(e.role))) {
+    return { archetype: 'FORM', reason: 'Has one or more data-entry form fields' };
+  }
+  return { archetype: 'GENERIC', reason: 'No distinguishing signals found' };
+}
+
+export interface ClassifiedScreen {
+  id: string;
+  name: string;
+  archetype: ScreenArchetype;
+}
+
+export interface JourneyCandidate {
+  startScreenId: string;
+  startScreenName: string;
+  startArchetype: ScreenArchetype;
+  endScreenId: string;
+  endScreenName: string;
+  endArchetype: ScreenArchetype;
+  label: string;
+}
+
+/** Archetype pairs worth generating a cross-screen journey test for, ranked
+ *  by how commonly they represent a real user flow. Order matters — earlier
+ *  entries are suggested before later ones when a project has many candidate
+ *  pairs. GENERIC is deliberately excluded from both sides: with no
+ *  distinguishing signal, pairing it with anything is a guess, not a
+ *  suggestion. */
+const INTERESTING_JOURNEYS: Array<{ from: ScreenArchetype; to: ScreenArchetype; label: string }> = [
+  { from: 'LOGIN', to: 'CHECKOUT', label: 'Login → Checkout' },
+  { from: 'SIGNUP', to: 'LOGIN', label: 'Signup → Login' },
+  { from: 'SEARCH', to: 'CHECKOUT', label: 'Search → Checkout' },
+  { from: 'LOGIN', to: 'FORM', label: 'Login → Form submission' },
+  { from: 'SEARCH', to: 'FORM', label: 'Search → Form submission' },
+];
+
+/**
+ * Finds every (start, end) screen pair whose archetypes match one of the
+ * interesting-journey rules. Pure and graph-agnostic on purpose — this does
+ * NOT check whether a KAG path actually connects the two screens (that
+ * requires a DB-backed BFS, see AppBrain.suggestJourneys in repository.ts,
+ * which calls this first to get a small, ranked candidate list and only then
+ * pays for a graph traversal per candidate instead of checking every
+ * archetype pair against every other screen).
+ */
+export function matchInterestingJourneyPairs(screens: ClassifiedScreen[]): JourneyCandidate[] {
+  const candidates: JourneyCandidate[] = [];
+  for (const rule of INTERESTING_JOURNEYS) {
+    const starts = screens.filter((s) => s.archetype === rule.from);
+    const ends = screens.filter((s) => s.archetype === rule.to);
+    for (const start of starts) {
+      for (const end of ends) {
+        if (start.id === end.id) continue;
+        candidates.push({
+          startScreenId: start.id,
+          startScreenName: start.name,
+          startArchetype: start.archetype,
+          endScreenId: end.id,
+          endScreenName: end.name,
+          endArchetype: end.archetype,
+          label: rule.label,
+        });
+      }
+    }
+  }
+  return candidates;
+}

package/src/cloud-storage.test.ts

@@ -0,0 +1,83 @@
+import crypto from 'node:crypto';
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { invalidateSystemConfigCache } from '@taodigital/core';
+import { prisma, prismaAdmin } from '@taodigital/database';
+import { getTenantStorageConfig } from './cloud-storage.js';
+
+// Run without AWS_S3_BUCKET/etc set (see packages/core's test:platform-storage script
+// for the platform-fallback-is-active case) — so getTenantStorageConfig()'s fallback
+// to a platform default is expected to resolve to null here, exercising the
+// "nothing configured at all" path deliberately.
+
+function id(prefix: string) {
+  return `${prefix}_${crypto.randomUUID()}`;
+}
+
+async function makeTenant() {
+  const tenantId = id('tenant');
+  await prisma.$transaction(async (tx) => {
+    await tx.$executeRawUnsafe(`SELECT set_config('app.current_tenant', $1, true)`, tenantId);
+    await tx.tenant.create({ data: { id: tenantId, name: 'Cloud Storage Test Tenant', slug: tenantId, isolation: 'SHARED', region: 'US' } });
+  });
+  return tenantId;
+}
+
+test('getTenantStorageConfig: returns null when tenant has no connector and no platform default is configured', async () => {
+  const rows = await prismaAdmin.systemConfig.findMany({ where: { category: 'storage' } });
+  await prismaAdmin.systemConfig.deleteMany({ where: { category: 'storage' } });
+  await prismaAdmin.systemConfig.createMany({
+    data: [
+      { key: 'storage.provider', category: 'storage', value: '', sensitive: false },
+      { key: 'storage.bucket', category: 'storage', value: '', sensitive: false },
+    ],
+  });
+  invalidateSystemConfigCache('storage');
+  try {
+    const tenantId = await makeTenant();
+    const cfg = await getTenantStorageConfig(tenantId);
+    assert.equal(cfg, null);
+  } finally {
+    await prismaAdmin.systemConfig.deleteMany({ where: { category: 'storage' } });
+    if (rows.length) {
+      await prismaAdmin.systemConfig.createMany({
+        data: rows.map(({ key, value, category, sensitive, updatedByAdminId }) => ({
+          key,
+          value,
+          category,
+          sensitive,
+          updatedByAdminId,
+        })),
+      });
+    }
+    invalidateSystemConfigCache('storage');
+  }
+});
+
+test('getTenantStorageConfig: returns the tenant-specific connector when one is configured', async () => {
+  const tenantId = await makeTenant();
+  const { encrypt } = await import('@taodigital/core');
+  await prisma.$transaction(async (tx) => {
+    await tx.$executeRawUnsafe(`SELECT set_config('app.current_tenant', $1, true)`, tenantId);
+    await tx.tenantSetting.create({
+      data: {
+        id: id('tsetting'),
+        tenantId,
+        category: 'STORAGE',
+        config: {
+          provider: 'S3',
+          bucket: 'tenant-own-bucket',
+          region: 'eu-west-1',
+          accessKeyId: 'AKIATENANT',
+          secretAccessKey_enc: encrypt('tenant-secret'),
+        },
+      },
+    });
+  });
+
+  const cfg = await getTenantStorageConfig(tenantId);
+  assert.ok(cfg);
+  assert.equal(cfg!.bucket, 'tenant-own-bucket');
+  assert.equal(cfg!.region, 'eu-west-1');
+  assert.equal(cfg!.secretAccessKey, 'tenant-secret');
+});