@ismaelsoilet/synapsejs 1.8.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

@@ -10,6 +10,7 @@ import { getEventHub } from '../runtime/event-hub';
 import type { DatabaseClient, QueryOptions, WhereCondition } from './database-client';
 import type { SessionContext } from './session-context';
 import { getStorage, type StorageClient } from './storage';
+import { declaredTopic, scopedTopic } from './topics';
 
 export interface StructuredLogger {
   info(message: string, context?: Record<string, unknown>): void;
@@ -20,6 +21,8 @@ export interface StructuredLogger {
 
 export interface JobEnqueueOptions {
   delaySeconds?: number;
+  /** Absolute execution timestamp in milliseconds. Mutually exclusive with delaySeconds. */
+  runAt?: number;
   priority?: number;
 }
 
@@ -32,8 +35,20 @@ export type EnqueueFn = <TPayload>(
 export type BroadcastFn = (topic: string, data: unknown) => number;
 
 export interface CookieOptions {
+  /**
+   * Defaults to true. A cookie written without stating otherwise is not readable by
+   * script; pass `false` explicitly to opt out.
+   */
   httpOnly?: boolean;
+  /**
+   * Defaults to true. A cookie written without stating otherwise is not sent over
+   * plaintext; pass `false` explicitly to opt out.
+   */
   secure?: boolean;
+  /**
+   * Defaults to `lax`. An explicit `strict` or `none` applies instead — the framework
+   * never infers a weaker policy from anything but a deliberate statement.
+   */
   sameSite?: 'lax' | 'strict' | 'none';
   maxAge?: number;
   path?: string;
@@ -46,6 +61,12 @@ export interface PendingCookie {
   options?: CookieOptions;
 }
 
+/**
+ * Serializes one response cookie. The safe attributes are the **defaults**: a cookie
+ * written with no options at all is HttpOnly, Secure and SameSite=Lax, and only an
+ * explicit `false` (or a different `sameSite`) changes that. This is a breaking
+ * change from the previous opt-in behaviour.
+ */
 export function serializeCookie(name: string, value: string, options: CookieOptions = {}): string {
   const parts = [`${encodeURIComponent(name)}=${encodeURIComponent(value)}`];
   if (options.maxAge !== undefined) {
@@ -56,15 +77,14 @@ export function serializeCookie(name: string, value: string, options: CookieOpti
   }
   const cleanPath = options.path && !/[\r\n;\s]/.test(options.path) ? options.path.trim() : '/';
   parts.push(`Path=${cleanPath}`);
-  if (options.secure) {
+  if (options.secure ?? true) {
     parts.push('Secure');
   }
-  if (options.httpOnly) {
+  if (options.httpOnly ?? true) {
     parts.push('HttpOnly');
   }
-  if (options.sameSite) {
-    parts.push(`SameSite=${options.sameSite.charAt(0).toUpperCase() + options.sameSite.slice(1).toLowerCase()}`);
-  }
+  const sameSite = options.sameSite ?? 'lax';
+  parts.push(`SameSite=${sameSite.charAt(0).toUpperCase() + sameSite.slice(1).toLowerCase()}`);
   return parts.join('; ');
 }
 
@@ -99,11 +119,14 @@ 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[];
-
-  /** Lazy adapter for Kysely (if configured or requested) */
-  readonly kysely?: unknown;
 }
 
 export function createDefaultLogger(sliceName?: string): StructuredLogger {
@@ -130,7 +153,11 @@ export interface ActionContextOptions<TServices = Record<string, unknown>> {
   storage?: StorageClient;
   broadcast?: BroadcastFn;
   invalidateCache?: (tags?: string[]) => void;
-  kysely?: unknown;
+  /**
+   * The slice key (`<domain>/<name>`) this context belongs to. Publishing into a
+   * declared topic is only allowed for the declaration's owner.
+   */
+  sliceOwner?: string;
 }
 
 /**
@@ -143,21 +170,77 @@ 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',
     storage = getStorage(),
-    broadcast = (topic: string, data: unknown) => getEventHub().publish(topic, data),
     invalidateCache = () => {},
-    kysely
+    sliceOwner
   } = options;
 
+  /**
+   * Publishing is declared, not inferred: the topic must exist in the session's
+   * tenant scope and this feature must be its declared owner. Anything else is
+   * rejected and notifies nobody.
+   */
+  const broadcast: BroadcastFn =
+    options.broadcast ??
+    ((topic: string, data: unknown) => {
+      const declaration = declaredTopic(topic, tenantId);
+
+      if (!declaration || (sliceOwner && declaration.owner !== sliceOwner)) {
+        logger.warn(
+          `Broadcast recusado no tópico "${topic}": não declarado${sliceOwner ? ` por ${sliceOwner}` : ''} (defineTopic).`
+        );
+        return 0;
+      }
+
+      return getEventHub().publish(scopedTopic(topic, tenantId), data);
+    });
+
   const pendingCookies: PendingCookie[] = [];
   const setCookie = (name: string, value: string, options?: CookieOptions) => {
     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,
@@ -170,8 +253,8 @@ export function createActionContext<TServices = Record<string, unknown>>(
     broadcast,
     invalidateCache,
     setCookie,
+    stream,
     _pendingCookies: pendingCookies,
-    kysely,
 
     // DatabaseClient proxy methods
     query: <T = unknown>(sql: string, params?: unknown[]) => db.query<T>(sql, params),
@@ -184,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
@@ -195,8 +281,8 @@ export function createActionContext<TServices = Record<string, unknown>>(
           logger,
           enqueue,
           storage,
-          broadcast,
-          kysely: txDb
+          broadcast: options.broadcast,
+          sliceOwner
         });
         return operation(txContext);
       });