@ismaelsoilet/synapsejs 1.9.0 → 1.11.1

package/src/compiler/slice-templates.ts

@@ -12,7 +12,15 @@
 
 import { generateTableColumnsCode, parseFields } from './fields-parser';
 
-export type SliceTemplate = 'create' | 'list' | 'update' | 'delete' | 'login' | 'oauth-github' | 'auth-2fa';
+export type SliceTemplate =
+  | 'create'
+  | 'list'
+  | 'update'
+  | 'delete'
+  | 'login'
+  | 'oauth-github'
+  | 'auth-2fa'
+  | 'modal-crud';
 export const SLICE_TEMPLATES: SliceTemplate[] = [
   'create',
   'list',
@@ -20,7 +28,8 @@ export const SLICE_TEMPLATES: SliceTemplate[] = [
   'delete',
   'login',
   'oauth-github',
-  'auth-2fa'
+  'auth-2fa',
+  'modal-crud'
 ];
 
 /** Paginação das listas geradas: o agente não escolhe esses números por conta. */
@@ -868,8 +877,8 @@ export async function ${names.actionName}(
   const input = payload as ${names.inputName};
   const email = input.email.trim().toLowerCase();
 
-  const rows = await db.query<{ id: string; password_hash: string; roles: string }>(
-    'SELECT id, password_hash, roles FROM users WHERE email = $1',
+  const rows = await db.query<{ id: string; password_hash: string; roles: string; permissions?: string }>(
+    'SELECT * FROM users WHERE email = $1',
     [email]
   );
   const user = rows[0];
@@ -884,10 +893,15 @@ export async function ${names.actionName}(
     .map((role) => role.trim())
     .filter((role) => role.length > 0);
 
+  const permissions = (user.permissions ?? '')
+    .split(',')
+    .map((permission) => permission.trim())
+    .filter((permission) => permission.length > 0);
+
   const expiresAt = Math.floor(Date.now() / 1000) + SESSION_MAX_AGE_SECONDS;
 
   return Ok({
-    token: signSessionToken({ userId: user.id, roles }, secret, SESSION_MAX_AGE_SECONDS),
+    token: signSessionToken({ userId: user.id, roles, permissions }, secret, SESSION_MAX_AGE_SECONDS),
     roles,
     expiresAt
   });
@@ -971,8 +985,8 @@ export const sliceTests = {
       run: async () => {
         process.env.SYNAPSE_SESSION_SECRET = 'segredo-de-teste';
         const hash = await Bun.password.hash('senha-com-oito');
-        const db = new MockDatabaseClient().onQuery(/SELECT id, password_hash, roles/, () => [
-          { id: 'user-1', password_hash: hash, roles: 'admin,billing' }
+        const db = new MockDatabaseClient().onQuery(/SELECT .* FROM users/, () => [
+          { id: 'user-1', password_hash: hash, roles: 'admin,billing', permissions: 'orders:read' }
         ]);
 
         const result = await ${names.actionName}({ email: '  Admin@Loja.com ', password: 'senha-com-oito' }, db);
@@ -985,7 +999,11 @@ export const sliceTests = {
         if (!verified.ok) {
           throw new Error(\`o servidor recusaria o token emitido: \${verified.error}\`);
         }
-        if (verified.value.userId !== 'user-1' || !verified.value.roles.includes('billing')) {
+        if (
+          verified.value.userId !== 'user-1' ||
+          !verified.value.roles.includes('billing') ||
+          !verified.value.permissions?.includes('orders:read')
+        ) {
           throw new Error(\`claims inesperadas: \${JSON.stringify(verified.value)}\`);
         }
         if (result.value.roles.join(',') !== 'admin,billing') {
@@ -998,7 +1016,7 @@ export const sliceTests = {
       run: async () => {
         process.env.SYNAPSE_SESSION_SECRET = 'segredo-de-teste';
         const hash = await Bun.password.hash('senha-com-oito');
-        const db = new MockDatabaseClient().onQuery(/SELECT id, password_hash, roles/, () => [
+        const db = new MockDatabaseClient().onQuery(/SELECT .* FROM users/, () => [
           { id: 'user-1', password_hash: hash, roles: 'user' }
         ]);
 
@@ -1013,7 +1031,7 @@ export const sliceTests = {
       name: 'usuário inexistente retorna INVALID_CREDENTIALS sem revelar que não existe',
       run: async () => {
         process.env.SYNAPSE_SESSION_SECRET = 'segredo-de-teste';
-        const db = new MockDatabaseClient().onQuery(/SELECT id, password_hash, roles/, () => []);
+        const db = new MockDatabaseClient().onQuery(/SELECT .* FROM users/, () => []);
 
         const result = await ${names.actionName}({ email: 'ninguem@b.com', password: 'senha-com-oito' }, db);
 
@@ -1510,6 +1528,210 @@ export const sliceTests = {
 `;
 }
 
+function modalCrudTemplate(names: TemplateNames, fieldsSpec?: string): string {
+  const fields = parseFields(fieldsSpec || 'name:string,description:string,status:enum(active|archived)');
+  const ddlColumns = generateTableColumnsCode(fields);
+  const tbProps = fields.map((f) => `  ${f.name}: Type.String()`).join(',\n');
+  const formFields = fields
+    .map((f) => `{ name: '${f.name}', label: '${f.name}', type: 'text', required: true }`)
+    .join(', ');
+
+  return `import React, { useState } from 'react';
+import { Type, Static } from '@sinclair/typebox';
+import { Value } from '@sinclair/typebox/value';
+import * as fc from 'fast-check';
+import {
+  type DatabaseClient,
+  Err,
+  MockDatabaseClient,
+  Ok,
+  type Result,
+  type SessionContext,
+  requireAuth
+} from 'synapsejs';
+import {
+  Button,
+  Card,
+  DataForm,
+  DataTable,
+  Drawer,
+  type FormField,
+  Modal,
+  useToast
+} from 'synapsejs/client';
+
+// ============================================================================
+// 1. CONTRATO DE ENTRADA (TypeBox)
+// ============================================================================
+export const ${names.schemaName} = Type.Object({
+${tbProps}
+}, { additionalProperties: true });
+export type ${names.inputName} = Static<typeof ${names.schemaName}>;
+
+// ============================================================================
+// 2. DDL SCHEMA DECLARATIVO
+// ============================================================================
+export const sliceSchema = \`
+  -- up:
+  CREATE TABLE IF NOT EXISTS ${names.table} (
+    id TEXT PRIMARY KEY,
+${ddlColumns},
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+  );
+  -- down:
+  DROP TABLE IF EXISTS ${names.table};
+\`;
+
+// ============================================================================
+// 3. MODELAGEM DE DOMÍNIO
+// ============================================================================
+export interface ${names.pascal}Row {
+  id: string;
+  name: string;
+  [key: string]: unknown;
+}
+
+export type ${names.outputName} = Result<
+  ${names.pascal}Row,
+  'INVALID_SCHEMA' | 'NO_DATABASE' | 'UNAUTHORIZED'
+>;
+
+// ============================================================================
+// 4. SERVER ACTION
+// ============================================================================
+export async function ${names.actionName}(
+  payload: unknown,
+  db?: DatabaseClient,
+  session?: SessionContext
+): Promise<${names.outputName}> {
+  if (!db) return Err('NO_DATABASE');
+  if (!Value.Check(${names.schemaName}, payload)) return Err('INVALID_SCHEMA');
+
+  const id = crypto.randomUUID();
+  const record: Record<string, unknown> = {
+    id,
+    ...(payload as Record<string, unknown>),
+    created_at: new Date().toISOString()
+  };
+
+  await db.insert('${names.table}', record);
+  return Ok(record as unknown as ${names.pascal}Row);
+}
+
+// ============================================================================
+// 5. SERVER LOADER (SSR)
+// ============================================================================
+export async function ${names.pascal}Loader(context: { db: DatabaseClient }) {
+  const rows = await context.db.findMany<${names.pascal}Row>('${names.table}', { limit: 50 });
+  return { rows };
+}
+
+// ============================================================================
+// 6. REACT UI — MODAL CRUD COM DRAWER E TOAST
+// ============================================================================
+const FORM_FIELDS: FormField[] = [${formFields}];
+
+export interface ${names.componentName}Props {
+  rows?: ${names.pascal}Row[];
+  onSubmitAction?: (payload: unknown) => Promise<${names.outputName}>;
+}
+
+export function ${names.componentName}({ rows = [], onSubmitAction }: ${names.componentName}Props) {
+  const [isModalOpen, setIsModalOpen] = useState(false);
+  const [selectedItem, setSelectedItem] = useState<${names.pascal}Row | null>(null);
+  const toast = useToast();
+
+  const handleCreate = async (formData: Record<string, unknown>) => {
+    if (!onSubmitAction) return;
+    const res = await onSubmitAction(formData);
+    if (res.ok) {
+      toast.success('Registro criado com sucesso!', '${names.pascal}');
+      setIsModalOpen(false);
+    } else {
+      toast.error('Erro ao salvar: ' + res.error);
+    }
+  };
+
+  return (
+    <div className="space-y-6">
+      <div className="flex items-center justify-between">
+        <div>
+          <h2 className="text-xl font-bold text-white tracking-tight">${names.pascal}</h2>
+          <p className="text-xs text-slate-400">Gerenciado com Modal e Drawer integrados</p>
+        </div>
+        <Button onClick={() => setIsModalOpen(true)}>➕ Novo Registro</Button>
+      </div>
+
+      <Card>
+        <DataTable
+          data={rows}
+          columns={[
+            { key: 'id', header: 'ID', render: (val) => <span className="font-mono text-xs">{String(val).slice(0, 8)}...</span> },
+            { key: 'name', header: 'Nome' },
+            {
+              key: 'actions',
+              header: 'Ações',
+              render: (_, row) => (
+                <Button size="sm" variant="secondary" onClick={() => setSelectedItem(row)}>
+                  Ver Detalhes
+                </Button>
+              )
+            }
+          ]}
+        />
+      </Card>
+
+      <Modal isOpen={isModalOpen} onClose={() => setIsModalOpen(false)} title="Cadastrar ${names.pascal}">
+        <DataForm fields={FORM_FIELDS} onSubmit={handleCreate} submitLabel="Salvar" />
+      </Modal>
+
+      <Drawer
+        isOpen={Boolean(selectedItem)}
+        onClose={() => setSelectedItem(null)}
+        title="Detalhes do Registro"
+        position="right"
+      >
+        {selectedItem && (
+          <div className="space-y-4 text-xs font-mono">
+            <pre className="p-4 bg-slate-950 rounded-xl border border-slate-800 text-slate-300 overflow-x-auto">
+              {JSON.stringify(selectedItem, null, 2)}
+            </pre>
+          </div>
+        )}
+      </Drawer>
+    </div>
+  );
+}
+
+// ============================================================================
+// 7. ORÁCULO DE TESTES (PBT)
+// ============================================================================
+export const sliceTests = {
+  description: 'Garantias invariantes do ${names.pascal} Modal CRUD',
+  cases: [
+    {
+      name: 'payload inválido retorna INVALID_SCHEMA',
+      run: async () => {
+        const res = await ${names.actionName}({ invalidField: 123 }, new MockDatabaseClient());
+        if (res.ok || res.error !== 'INVALID_SCHEMA') {
+          throw new Error('Deveria recusar payload fora do schema');
+        }
+      }
+    },
+    {
+      name: 'sem conexão de banco retorna NO_DATABASE',
+      run: async () => {
+        const res = await ${names.actionName}({ name: 'Teste' });
+        if (res.ok || res.error !== 'NO_DATABASE') {
+          throw new Error('Deveria acusar NO_DATABASE');
+        }
+      }
+    }
+  ]
+};
+`;
+}
+
 export function generateOperationTemplate(
   domain: string,
   sliceName: string,
@@ -1531,6 +1753,8 @@ export function generateOperationTemplate(
       return oauthGithubTemplate(names);
     case 'auth-2fa':
       return auth2faTemplate(names);
+    case 'modal-crud':
+      return modalCrudTemplate(names, fieldsSpec);
     default:
       throw new Error(`Template desconhecido: ${template}`);
   }

package/src/compiler/typescript-api.ts

@@ -0,0 +1,33 @@
+/**
+ * SynapseJS - TypeScript compiler API guard.
+ *
+ * The splitter, checker and repo-map generator use the in-process JavaScript
+ * compiler API. TypeScript 7 (the native compiler) ships a CLI-only package and
+ * removed that API, so resolving it must fail with a named, actionable error
+ * instead of a `TypeError` deep inside the compiler.
+ */
+
+import * as ts from 'typescript';
+
+export const COMPILER_API_UNAVAILABLE = 'COMPILER_API_UNAVAILABLE';
+
+interface CompilerModuleShape {
+  version?: string;
+  sys?: { readFile?: unknown };
+  createProgram?: unknown;
+}
+
+export function assertCompilerApi(module: unknown = ts): void {
+  const candidate = module as CompilerModuleShape;
+
+  if (typeof candidate?.sys?.readFile === 'function' && typeof candidate.createProgram === 'function') {
+    return;
+  }
+
+  const error = new Error(
+    `${COMPILER_API_UNAVAILABLE}: TypeScript ${candidate?.version ?? 'unknown'} does not expose the in-process compiler API required by SynapseJS. Use TypeScript 5.9.x (the pinned version) or run the compiler through its CLI.`
+  ) as Error & { code: string };
+
+  error.code = COMPILER_API_UNAVAILABLE;
+  throw error;
+}

package/src/core/action-context.ts

@@ -21,6 +21,8 @@ export interface StructuredLogger {
 
 export interface JobEnqueueOptions {
   delaySeconds?: number;
+  /** Absolute execution timestamp in milliseconds. Mutually exclusive with delaySeconds. */
+  runAt?: number;
   priority?: number;
 }
 
@@ -117,6 +119,12 @@ export interface ActionContext<TServices = Record<string, unknown>> extends Data
   /** Sets an HTTP response cookie (e.g. HttpOnly session token) */
   readonly setCookie: (name: string, value: string, options?: CookieOptions) => void;
 
+  /** Emits an HTTP chunked or SSE streaming response for real-time AI/LLM tokens */
+  readonly stream: (
+    generator: AsyncIterable<string | Uint8Array> | (() => AsyncGenerator<string | Uint8Array>),
+    options?: { contentType?: string; status?: number; headers?: Record<string, string> }
+  ) => Response;
+
   /** Internal list of pending cookies to be set on the response */
   readonly _pendingCookies?: PendingCookie[];
 }
@@ -162,7 +170,7 @@ export function createActionContext<TServices = Record<string, unknown>>(
   const {
     db,
     session,
-    tenantId = session.tenantId,
+    tenantId = session?.tenantId,
     services = {} as TServices,
     logger = createDefaultLogger(),
     enqueue = async () => 'job_noop',
@@ -196,6 +204,43 @@ export function createActionContext<TServices = Record<string, unknown>>(
     pendingCookies.push({ name, value, options });
   };
 
+  const stream = (
+    generator: AsyncIterable<string | Uint8Array> | (() => AsyncGenerator<string | Uint8Array>),
+    streamOptions?: { contentType?: string; status?: number; headers?: Record<string, string> }
+  ): Response => {
+    const iterable = typeof generator === 'function' ? generator() : generator;
+    const encoder = new TextEncoder();
+
+    const readable = new ReadableStream({
+      async start(controller) {
+        try {
+          for await (const chunk of iterable) {
+            if (typeof chunk === 'string') {
+              controller.enqueue(encoder.encode(chunk));
+            } else {
+              controller.enqueue(chunk);
+            }
+          }
+          controller.close();
+        } catch (err) {
+          controller.error(err);
+        }
+      }
+    });
+
+    const headers = new Headers({
+      'Content-Type': streamOptions?.contentType || 'text/plain; charset=utf-8',
+      'Transfer-Encoding': 'chunked',
+      'X-Content-Type-Options': 'nosniff',
+      ...(streamOptions?.headers || {})
+    });
+
+    return new Response(readable, {
+      status: streamOptions?.status || 200,
+      headers
+    });
+  };
+
   const context: ActionContext<TServices> = {
     // ActionContext properties
     db,
@@ -208,6 +253,7 @@ export function createActionContext<TServices = Record<string, unknown>>(
     broadcast,
     invalidateCache,
     setCookie,
+    stream,
     _pendingCookies: pendingCookies,
 
     // DatabaseClient proxy methods
@@ -221,6 +267,9 @@ export function createActionContext<TServices = Record<string, unknown>>(
     update: <T = unknown>(table: string, data: Record<string, unknown>, where: WhereCondition) =>
       db.update<T>(table, data, where),
     delete: (table: string, where: WhereCondition) => db.delete(table, where),
+    count: (table: string, where?: WhereCondition) => db.count(table, where),
+    exists: (table: string, where: WhereCondition) => db.exists(table, where),
+    aggregate: <T = Record<string, unknown>>(table: string, options: QueryOptions) => db.aggregate<T>(table, options),
     transaction: async <T>(operation: (tx: DatabaseClient) => Promise<T>): Promise<T> => {
       return db.transaction(async (txDb) => {
         // Create transactional ActionContext preserving services and context

package/src/core/cron-parser.ts

@@ -0,0 +1,167 @@
+/**
+ * SynapseJS - Zero-Dependency 5-Field Standard Cron Expression Parser
+ *
+ * Evaluates standard cron strings (minute, hour, day-of-month, month, day-of-week)
+ * and calculates the exact next UTC execution timestamp deterministically.
+ *
+ * Day-of-month and day-of-week follow POSIX/Vixie semantics: when both fields are
+ * restricted, the expression matches the union of the two (OR), not the
+ * intersection. Names, L, W, # and ? are rejected explicitly instead of silently
+ * searching for an impossible date.
+ */
+
+export interface ParsedCronField {
+  matches(val: number): boolean;
+}
+
+function matchesField(value: number, sundaySeven: boolean, predicate: (value: number) => boolean): boolean {
+  return predicate(value) || (sundaySeven && value === 0 && predicate(7));
+}
+
+function parseField(field: string, min: number, max: number, sundaySeven = false): ParsedCronField {
+  const trimmed = field.trim();
+  if (trimmed === '*') {
+    return { matches: () => true };
+  }
+
+  // Handle step: */5 or 10-30/5
+  if (trimmed.includes('/')) {
+    const [rangePart, stepPart] = trimmed.split('/');
+    const step = Number.parseInt(stepPart, 10);
+    if (Number.isNaN(step) || step <= 0) {
+      throw new Error(`Invalid cron step: "${stepPart}" in "${field}"`);
+    }
+
+    let start = min;
+    let end = max;
+    if (rangePart !== '*') {
+      if (rangePart.includes('-')) {
+        const [rawStart, rawEnd] = rangePart.split('-').map((n) => Number.parseInt(n, 10));
+        if (Number.isNaN(rawStart) || Number.isNaN(rawEnd) || rawStart < min || rawEnd > max || rawStart > rawEnd) {
+          throw new Error(`Invalid cron range: "${rangePart}" in "${field}"`);
+        }
+        start = rawStart;
+        end = rawEnd;
+      } else {
+        const rawStart = Number.parseInt(rangePart, 10);
+        if (Number.isNaN(rawStart) || rawStart < min || rawStart > max) {
+          throw new Error(`Invalid cron number: "${rangePart}" (expected ${min}-${max})`);
+        }
+        start = rawStart;
+      }
+    }
+
+    return {
+      matches: (val: number) =>
+        matchesField(val, sundaySeven, (value) => value >= start && value <= end && (value - start) % step === 0)
+    };
+  }
+
+  // Handle list: 1,2,5
+  if (trimmed.includes(',')) {
+    const subParsers = trimmed.split(',').map((part) => parseField(part, min, max, sundaySeven));
+    return {
+      matches: (val: number) => subParsers.some((parser) => parser.matches(val))
+    };
+  }
+
+  // Handle range: 1-5
+  if (trimmed.includes('-')) {
+    const [start, end] = trimmed.split('-').map((n) => Number.parseInt(n, 10));
+    if (Number.isNaN(start) || Number.isNaN(end) || start > end || start < min || end > max) {
+      throw new Error(`Invalid cron range: "${field}"`);
+    }
+    return {
+      matches: (val: number) => matchesField(val, sundaySeven, (value) => value >= start && value <= end)
+    };
+  }
+
+  // Exact number: 5
+  const exact = Number.parseInt(trimmed, 10);
+  if (Number.isNaN(exact) || exact < min || exact > max) {
+    throw new Error(`Invalid cron number: "${trimmed}" (expected ${min}-${max})`);
+  }
+  return {
+    matches: (val: number) => matchesField(val, sundaySeven, (value) => value === exact)
+  };
+}
+
+export function parseNextCronOccurrence(cronExpr: string, fromDate: Date = new Date()): Date {
+  const parts = cronExpr.trim().split(/\s+/);
+  if (parts.length !== 5) {
+    throw new Error(`Cron expression must contain exactly 5 parts (got ${parts.length}): "${cronExpr}"`);
+  }
+
+  for (const part of parts) {
+    if (/[A-Za-z?#]/.test(part)) {
+      throw new Error(
+        `Unsupported cron syntax: "${part}". Names, L, W, # and ? are not supported; use numbers, ranges, lists and steps.`
+      );
+    }
+  }
+
+  const minuteField = parseField(parts[0], 0, 59);
+  const hourField = parseField(parts[1], 0, 23);
+  const dayOfMonthField = parseField(parts[2], 1, 31);
+  const monthField = parseField(parts[3], 1, 12);
+  // Sunday is accepted as 0 or 7; the field matcher tests both representations.
+  const dayOfWeekField = parseField(parts[4], 0, 7, true);
+
+  const dayOfMonthRestricted = parts[2].trim() !== '*';
+  const dayOfWeekRestricted = parts[4].trim() !== '*';
+
+  // Start checking from the next whole minute
+  const candidate = new Date(fromDate.getTime());
+  candidate.setUTCSeconds(0, 0);
+  candidate.setUTCMinutes(candidate.getUTCMinutes() + 1);
+
+  // Limit search to 5 years (approx 2,628,000 minutes) to prevent infinite loops on impossible dates
+  const maxIterations = 5 * 365 * 24 * 60;
+  let iterations = 0;
+
+  while (iterations < maxIterations) {
+    const month = candidate.getUTCMonth() + 1; // 1-12
+    if (!monthField.matches(month)) {
+      // Advance to start of next month
+      candidate.setUTCMonth(candidate.getUTCMonth() + 1, 1);
+      candidate.setUTCHours(0, 0, 0, 0);
+      iterations += 60;
+      continue;
+    }
+
+    const dayOfMonth = candidate.getUTCDate();
+    const dayOfWeek = candidate.getUTCDay(); // 0 = Sunday
+    const dayOfMonthMatches = dayOfMonthField.matches(dayOfMonth);
+    const dayOfWeekMatches = dayOfWeekField.matches(dayOfWeek);
+    const dayMatches =
+      dayOfMonthRestricted && dayOfWeekRestricted
+        ? dayOfMonthMatches || dayOfWeekMatches
+        : dayOfMonthMatches && dayOfWeekMatches;
+
+    if (!dayMatches) {
+      // Advance to start of next day
+      candidate.setUTCDate(candidate.getUTCDate() + 1);
+      candidate.setUTCHours(0, 0, 0, 0);
+      iterations += 60;
+      continue;
+    }
+
+    const hour = candidate.getUTCHours();
+    if (!hourField.matches(hour)) {
+      // Advance to next hour
+      candidate.setUTCHours(candidate.getUTCHours() + 1, 0, 0, 0);
+      iterations += 60;
+      continue;
+    }
+
+    const minute = candidate.getUTCMinutes();
+    if (minuteField.matches(minute)) {
+      return candidate;
+    }
+
+    candidate.setUTCMinutes(candidate.getUTCMinutes() + 1);
+    iterations++;
+  }
+
+  throw new Error(`Unable to find next execution for cron expression: "${cronExpr}" within search horizon.`);
+}

package/src/core/database-client.ts

@@ -99,6 +99,21 @@ export interface DatabaseClient {
    */
   delete(table: string, where: WhereCondition): Promise<number>;
 
+  /**
+   * Declarative row count with optional WHERE filter.
+   */
+  count(table: string, where?: WhereCondition): Promise<number>;
+
+  /**
+   * Declarative existence check returning true if at least one matching row exists.
+   */
+  exists(table: string, where: WhereCondition): Promise<boolean>;
+
+  /**
+   * Declarative aggregation and grouping query.
+   */
+  aggregate<T = Record<string, unknown>>(table: string, options: QueryOptions): Promise<T[]>;
+
   /**
    * Execute command inside a database transaction boundary.
    */
@@ -290,6 +305,26 @@ export class MockDatabaseClient implements DatabaseClient {
     return removed;
   }
 
+  async count(table: string, where?: WhereCondition): Promise<number> {
+    const rows = await this.findMany(table, { where });
+    return rows.length;
+  }
+
+  async exists(table: string, where: WhereCondition): Promise<boolean> {
+    const rows = await this.findMany(table, { where, limit: 1 });
+    return rows.length > 0;
+  }
+
+  async aggregate<T = Record<string, unknown>>(table: string, options: QueryOptions): Promise<T[]> {
+    if (options.aggregations?.length || options.groupBy || options.having) {
+      throw new Error(
+        'UNSUPPORTED_OPERATION: MockDatabaseClient.aggregate does not implement aggregations, grouping or HAVING; use a real database for that assertion'
+      );
+    }
+
+    return this.findMany<T>(table, options);
+  }
+
   async transaction<T>(operation: (tx: DatabaseClient) => Promise<T>): Promise<T> {
     const snapshot = new Map(
       Array.from(this.tables.entries()).map(([table, rows]) => [table, rows.map((row) => ({ ...row }))])

package/src/core/index.ts

@@ -2,11 +2,13 @@ export * from './action-context';
 export * from './action-definition';
 export * from './cache';
 export * from './config';
+export * from './cron-parser';
 export * from './database-client';
 export * from './database-factory';
 export * from './image-optimizer';
 export * from './jobs';
 export * from './machine-types';
+export * from './oauth-client';
 export * from './path-guard';
 export * from './postgres-client';
 export * from './postgres-queue';