@ismaelsoilet/synapsejs 1.4.0 → 1.9.0

package/src/client/outlet.tsx

@@ -0,0 +1,40 @@
+import type React from 'react';
+import { createContext, type ReactNode, useContext } from 'react';
+
+export interface SliceOutletContextValue {
+  content?: ReactNode;
+  outlets?: Record<string, ReactNode>;
+}
+
+const SliceOutletContext = createContext<SliceOutletContextValue>({});
+
+export interface SliceOutletProviderProps {
+  content?: ReactNode;
+  outlets?: Record<string, ReactNode>;
+  children: ReactNode;
+}
+
+export function SliceOutletProvider({ content, outlets = {}, children }: SliceOutletProviderProps) {
+  return <SliceOutletContext.Provider value={{ content, outlets }}>{children}</SliceOutletContext.Provider>;
+}
+
+export interface SliceOutletProps {
+  name?: string;
+  fallback?: ReactNode;
+  children?: ReactNode;
+}
+
+/**
+ * <SliceOutlet /> renders nested content within Root or Domain Layouts,
+ * enabling parallel sub-panels and composable nested views.
+ */
+export function SliceOutlet({ name, fallback = null, children }: SliceOutletProps): React.ReactElement | null {
+  const ctx = useContext(SliceOutletContext);
+  if (children) {
+    return <>{children}</>;
+  }
+  if (name && ctx.outlets) {
+    return <>{ctx.outlets[name] ?? fallback}</>;
+  }
+  return <>{ctx.content ?? fallback}</>;
+}

package/src/client/sub-slice.tsx

@@ -0,0 +1,45 @@
+import React, { type ComponentType, type ReactElement, useMemo } from 'react';
+import { rpcCall } from '../core/rpc-client';
+import { SynapseProvider } from './context';
+
+export interface SubSliceProps<TProps extends Record<string, unknown> = Record<string, unknown>> {
+  domain: string;
+  name: string;
+  // biome-ignore lint/suspicious/noExplicitAny: dynamic component props boundary
+  component?: ComponentType<any>;
+  props?: TProps;
+  actionPropNames?: string[];
+  children?: (injectedProps: Record<string, unknown>) => ReactElement;
+}
+
+/**
+ * <SubSlice /> dynamically embeds a sub-slice component into any layout or parent view,
+ * automatically wiring its transparent RPC action endpoint without violating Locality of Behavior (N = 1).
+ */
+export function SubSlice<TProps extends Record<string, unknown> = Record<string, unknown>>({
+  domain,
+  name,
+  component: Component,
+  props = {} as TProps,
+  actionPropNames = ['action', 'onSubmitAction'],
+  children
+}: SubSliceProps<TProps>): ReactElement {
+  const rpcPath = `/_synapse/rpc/${domain}/${name}`;
+
+  const boundActions = useMemo(() => {
+    const actions: Record<string, (payload: unknown) => Promise<unknown>> = {};
+    for (const actionName of actionPropNames) {
+      actions[actionName] = (payload: unknown) => rpcCall(rpcPath, payload);
+    }
+    return actions;
+  }, [rpcPath, actionPropNames]);
+
+  const mergedProps = {
+    ...props,
+    ...boundActions
+  };
+
+  const content = children ? children(mergedProps) : Component ? React.createElement(Component, mergedProps) : null;
+
+  return <SynapseProvider props={mergedProps}>{content}</SynapseProvider>;
+}

package/src/client/use-websocket.ts

@@ -0,0 +1,146 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+
+export interface UseWebSocketOptions<TServerMsg = unknown> {
+  enabled?: boolean;
+  reconnect?: boolean;
+  reconnectIntervalMs?: number;
+  onOpen?: () => void;
+  onMessage?: (message: TServerMsg) => void;
+  onClose?: (event: CloseEvent) => void;
+  onError?: (event: Event) => void;
+}
+
+export interface UseWebSocketResult<TServerMsg = unknown, TClientMsg = unknown> {
+  isConnected: boolean;
+  lastMessage: TServerMsg | null;
+  send: (data: TClientMsg | string) => void;
+  close: () => void;
+  error: Error | null;
+}
+
+/**
+ * Hook for bidirectional WebSocket communication with SynapseJS slices.
+ */
+export function useWebSocket<TServerMsg = unknown, TClientMsg = unknown>(
+  pathOrSlice: string,
+  options: UseWebSocketOptions<TServerMsg> = {}
+): UseWebSocketResult<TServerMsg, TClientMsg> {
+  const { enabled = true, reconnect = true, reconnectIntervalMs = 3000 } = options;
+
+  const [isConnected, setIsConnected] = useState<boolean>(false);
+  const [lastMessage, setLastMessage] = useState<TServerMsg | null>(null);
+  const [error, setError] = useState<Error | null>(null);
+
+  const socketRef = useRef<WebSocket | null>(null);
+  const optionsRef = useRef(options);
+  optionsRef.current = options;
+
+  const resolveUrl = useCallback((path: string): string => {
+    if (typeof window === 'undefined') return '';
+    if (path.startsWith('ws://') || path.startsWith('wss://')) return path;
+
+    const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+    const host = window.location.host;
+
+    if (path.startsWith('/')) {
+      return `${protocol}//${host}${path}`;
+    }
+    // Formato <domain>/<name>
+    return `${protocol}//${host}/_synapse/ws/${path}`;
+  }, []);
+
+  useEffect(() => {
+    if (!enabled || typeof window === 'undefined') return;
+
+    let isMounted = true;
+    let reconnectTimeout: ReturnType<typeof setTimeout> | null = null;
+
+    const connect = () => {
+      try {
+        const url = resolveUrl(pathOrSlice);
+        if (!url) return;
+
+        const ws = new WebSocket(url);
+        socketRef.current = ws;
+
+        ws.onopen = () => {
+          if (!isMounted) return;
+          setIsConnected(true);
+          setError(null);
+          optionsRef.current.onOpen?.();
+        };
+
+        ws.onmessage = (event) => {
+          if (!isMounted) return;
+          try {
+            const data = JSON.parse(event.data) as TServerMsg;
+            setLastMessage(data);
+            optionsRef.current.onMessage?.(data);
+          } catch {
+            const raw = event.data as unknown as TServerMsg;
+            setLastMessage(raw);
+            optionsRef.current.onMessage?.(raw);
+          }
+        };
+
+        ws.onerror = (e) => {
+          if (!isMounted) return;
+          const err = new Error(`Erro na conexão WebSocket para "${pathOrSlice}"`);
+          setError(err);
+          optionsRef.current.onError?.(e);
+        };
+
+        ws.onclose = (e) => {
+          if (!isMounted) return;
+          setIsConnected(false);
+          optionsRef.current.onClose?.(e);
+
+          if (reconnect && isMounted && !e.wasClean) {
+            reconnectTimeout = setTimeout(connect, reconnectIntervalMs);
+          }
+        };
+      } catch (err) {
+        if (!isMounted) return;
+        setError(err instanceof Error ? err : new Error(String(err)));
+      }
+    };
+
+    connect();
+
+    return () => {
+      isMounted = false;
+      if (reconnectTimeout) clearTimeout(reconnectTimeout);
+      if (socketRef.current) {
+        socketRef.current.close();
+        socketRef.current = null;
+      }
+      setIsConnected(false);
+    };
+  }, [pathOrSlice, enabled, reconnect, reconnectIntervalMs, resolveUrl]);
+
+  const send = useCallback(
+    (data: TClientMsg | string) => {
+      if (socketRef.current && socketRef.current.readyState === WebSocket.OPEN) {
+        const payload = typeof data === 'string' ? data : JSON.stringify(data);
+        socketRef.current.send(payload);
+      } else {
+        console.warn(`[useWebSocket] Tentativa de envio em socket desconectado (${pathOrSlice})`);
+      }
+    },
+    [pathOrSlice]
+  );
+
+  const close = useCallback(() => {
+    if (socketRef.current) {
+      socketRef.current.close();
+    }
+  }, []);
+
+  return {
+    isConnected,
+    lastMessage,
+    send,
+    close,
+    error
+  };
+}

package/src/client.ts

@@ -53,6 +53,18 @@ export {
   type TranslateFn,
   type TranslationDictionary
 } from './client/i18n';
+export {
+  SliceOutlet,
+  type SliceOutletProps,
+  SliceOutletProvider,
+  type SliceOutletProviderProps
+} from './client/outlet';
+export { SubSlice, type SubSliceProps } from './client/sub-slice';
+export {
+  type UseWebSocketOptions,
+  type UseWebSocketResult,
+  useWebSocket
+} from './client/use-websocket';
 export type { Result } from './core/machine-types';
 export { type RpcTransportError, rpcCall, rpcTransportFailure } from './core/rpc-client';
 export type { SessionContext } from './core/session-context';

package/src/compiler/client-bundler.ts

@@ -61,11 +61,16 @@ export function clientManifestPath(baseDir: string): string {
   return path.join(baseDir, '.synapse', 'client', 'manifest.json');
 }
 
-export async function buildVendorBundle(baseDir: string): Promise<Result<BuiltBundle, BuildError>> {
+export async function buildVendorBundle(
+  baseDir: string,
+  vendorPackages: string[] = []
+): Promise<Result<BuiltBundle, BuildError>> {
   const vendorEntryDir = path.join(baseDir, '.synapse/client-entry');
   fs.mkdirSync(vendorEntryDir, { recursive: true });
   const vendorEntryPath = path.join(vendorEntryDir, '_vendor.ts');
 
+  const extraExports = (vendorPackages || []).map((pkg) => `export * from '${pkg}';`).join('\n');
+
   const vendorEntryContent = [
     `import React from 'react';`,
     `import * as ReactDOM from 'react-dom';`,
@@ -73,6 +78,7 @@ export async function buildVendorBundle(baseDir: string): Promise<Result<BuiltBu
     `import * as SynapseClient from 'synapsejs/client';`,
     `import * as jsxRuntime from 'react/jsx-runtime';`,
     `import * as jsxDevRuntime from 'react/jsx-dev-runtime';`,
+    ...(extraExports ? [extraExports] : []),
     ``,
     `export default React;`,
     `export * from 'react';`,
@@ -209,7 +215,8 @@ export function componentExportOf(module: Record<string, unknown>): string | und
 
 export async function buildClientBundle(
   target: BundleTarget,
-  baseDir: string
+  baseDir: string,
+  options?: { vendorPackages?: string[] }
 ): Promise<Result<BuiltBundle, BuildError>> {
   // Uma fatia que não carrega não pode derrubar o build inteiro: ela vira FAIL com o motivo.
   let sliceModule: Record<string, unknown>;
@@ -311,7 +318,7 @@ export async function buildClientBundle(
   if (vendorSplit) {
     const vendorFile = path.join(baseDir, '.synapse/client', VENDOR_BUNDLE_NAME);
     if (!fs.existsSync(vendorFile)) {
-      await buildVendorBundle(baseDir);
+      await buildVendorBundle(baseDir, options?.vendorPackages);
     }
   }
 
@@ -334,7 +341,8 @@ export async function buildClientBundle(
             'react-dom',
             'react-dom/client',
             'synapsejs/client',
-            '@ismaelsoilet/synapsejs/client'
+            '@ismaelsoilet/synapsejs/client',
+            ...(options?.vendorPackages || [])
           ]
         : [],
       define: { 'process.env.NODE_ENV': production ? '"production"' : '"development"' }
@@ -421,7 +429,8 @@ export interface BuildReportEntry {
  * component and fails to produce a bundle is a broken build.
  */
 export async function buildAllClientBundles(
-  appRoot: string
+  appRoot: string,
+  options?: { vendorPackages?: string[] }
 ): Promise<Result<{ entries: BuildReportEntry[]; manifestFile: string }, SlicesDirError>> {
   const resolution = resolveSlicesDir(appRoot);
 
@@ -433,7 +442,7 @@ export async function buildAllClientBundles(
   const entries: BuildReportEntry[] = [];
   const built: BuiltBundle[] = [];
 
-  const vendorRes = await buildVendorBundle(appRoot);
+  const vendorRes = await buildVendorBundle(appRoot, options?.vendorPackages);
   if (vendorRes.ok) {
     built.push(vendorRes.value);
     entries.push({ slice: '_vendor', status: 'PASS', url: vendorRes.value.url, bytes: vendorRes.value.bytes });
@@ -446,7 +455,8 @@ export async function buildAllClientBundles(
 
     const bundle = await buildClientBundle(
       { key, name, domain, filePath: file, rpcPath: `/_synapse/rpc/${domain}/${name}` },
-      appRoot
+      appRoot,
+      options
     );
 
     if (bundle.ok) {

package/src/compiler/context-bench.ts

@@ -174,7 +174,7 @@ export function measureAppSurface(appRoot: string): AppSurface {
 
 export function renderSurfaceReport(surfaces: AppSurface[]): string {
   const lines = [
-    '| app | feature | arquivos (app) | tokens (app, est.) | arquivos (total) | tokens (total, est.) |',
+    '| app | feature | arquivos (app) | tokens (app, est.) | arquivos (total, não comparável) | tokens (total, est., não comparável) |',
     '|---|---|---|---|---|---|'
   ];
 
@@ -187,5 +187,11 @@ export function renderSurfaceReport(surfaces: AppSurface[]): string {
     }
   }
 
+  lines.push(
+    '',
+    'As colunas `app` são as comparáveis (os arquivos da própria funcionalidade em cada aplicação).',
+    'As colunas `total` cobrem conjuntos de arquivos diferentes por repositório e não são comparáveis'
+  );
+
   return lines.join('\n');
 }

package/src/compiler/contract.ts

@@ -11,6 +11,8 @@
  * discovery and the splitter use, so the description cannot drift from behavior.
  */
 
+import { PATH_SEGMENT_PATTERN } from '../core/path-guard';
+import { REALTIME_REJECTIONS } from '../core/topics';
 import {
   ACTION_SUFFIX,
   COMPONENT_SUFFIXES,
@@ -18,6 +20,7 @@ import {
   SLICE_DDL_EXPORT,
   SLICE_ORACLE_EXPORT
 } from '../runtime/discovery-rules';
+import { SCAFFOLD_FAILURE_CODES } from './scaffolder';
 import { SLICE_EXTENSION } from './slice-discovery';
 import { SLICE_TEMPLATES } from './slice-templates';
 
@@ -49,6 +52,7 @@ export interface MachineContract {
     signed: string;
     anonymous: string;
     login: string;
+    cookieReality: string;
   };
   addressing: {
     page: string;
@@ -71,6 +75,16 @@ export interface MachineContract {
     available: string[];
     notes: string;
   };
+  scaffolding: {
+    command: string;
+    containment: string;
+    failureCodes: Record<string, string>;
+  };
+  realtime: {
+    transports: string[];
+    rule: string;
+    rejections: Record<string, number>;
+  };
   gates: Array<{ command: string; proves: string }>;
 }
 
@@ -187,16 +201,18 @@ export function machineContract(): MachineContract {
     sessions: {
       headers: ['Authorization: Bearer <token>', 'x-user-id', 'x-user-roles'],
       signed:
-        'With SYNAPSE_SESSION_SECRET set, a bearer token must be a signed session (signSessionToken) and its claims win: role headers are ignored.',
+        'With SYNAPSE_SESSION_SECRET set, a bearer token must be a signed session (signSessionToken) and its claims win: role headers are ignored, and the tenant is taken exclusively from the verified claims (a signed token without a tenant claim yields a session without a tenant). Revocation is consulted on every request, in-process first and then against the persisted blacklist. Without the secret, identity headers are honoured only under the explicit development opt-in SYNAPSE_DEV_HEADERS=true (or a development/test runtime mode); every other state resolves to an anonymous session.',
       anonymous: 'A request with none of them is anonymous: requireAuth returns Err("UNAUTHORIZED").',
       login:
-        'There is no built-in login screen and no server-side session state. A login slice (synapse new-slice auth login --template=login) verifies the password with Bun.password.verify, signs the session with signSessionToken and returns the token; the browser stores it with storeSession(token, roles) and logs out with clearSession(). After that the token travels as Authorization: Bearer and the server authorizes from the signature.'
+        'There is no built-in login screen and no server-side session state. A login slice (synapse new-slice auth login --template=login) verifies the password with Bun.password.verify, signs the session with signSessionToken and returns the token; the browser stores it with storeSession(token, roles) and logs out with clearSession(). After that the token travels as Authorization: Bearer and the server authorizes from the signature.',
+      cookieReality:
+        'A session cookie written by browser script (storeSession) is written through document.cookie, so it is readable by any script in the origin — HttpOnly cannot be set from script, by construction. A session that must be unreachable by script is the one the server emits through ctx.setCookie, which carries HttpOnly, Secure and SameSite=Lax unless the caller states otherwise.'
     },
     addressing: {
       page: 'GET /<domain>/<name>',
       rpc: 'POST /_synapse/rpc/<domain>/<name> with Content-Type: application/json',
       upload:
-        'POST /_synapse/files/<domain>/<name>?name=arquivo.pdf sends raw bytes (multipart is not needed and not parsed). It requires a session, refuses a name containing a directory, and stops reading past SYNAPSE_MAX_UPLOAD_BYTES (5 MiB by default). It answers { ok, path, bytes } with a path relative to the app root; what the bytes mean is the slice contract to decide.',
+        "POST /_synapse/files/<domain>/<name>?name=arquivo.pdf sends raw bytes or multipart/form-data. It requires a session, refuses a name containing a directory, enforces a byte ceiling while the bytes arrive on every branch (SYNAPSE_MAX_UPLOAD_BYTES, 5 MiB by default), and accepts a file only when its declared extension is within the configured policy (SYNAPSE_UPLOAD_ALLOWED_TYPES) and matches the bytes actually received — so a client cannot choose the extension its file is stored under. It answers { ok, path, bytes } with a path relative to the app root. The framework does not serve the upload directory: serving it is the application's responsibility.",
       ambiguity:
         'A bare name resolves only while it is unique across domains; otherwise the dispatcher answers 409 listing the candidates.'
     },
@@ -211,7 +227,7 @@ export function machineContract(): MachineContract {
       location: 'src/shared/<name>.ts',
       rule: 'A slice never imports another slice — the splitter fails with SLICE_IMPORTS_SLICE, transitively, and says so. What two features must do together lives in src/shared/, receives the DatabaseClient by parameter and is called from both slices. A shared module may throw; the action that calls it converts the failure into Err, so the no-throw contract of an action survives a transaction.',
       atomicity:
-        'db.transaction(fn) is the boundary: the statements inside commit together or roll back together. The mock database does not roll back, so atomicity must be proven against a real engine (SQLite in the suite, PostgreSQL via test:postgres) — never with the mock.'
+        'db.transaction(fn) is the boundary: the statements inside commit together or roll back together. The mock database rolls back its in-memory store, which makes it usable for control-flow assertions, but atomicity against a real engine (SQLite in the suite, PostgreSQL via test:postgres) is what proves the engine agrees.'
     },
     templates: {
       command: 'synapse new-slice <domain> <name> --template=<template>',
@@ -219,6 +235,17 @@ export function machineContract(): MachineContract {
       notes:
         'create is the default. crud generates create-<name>, list-<name>, update-<name> and delete-<name> for one resource. list paginates (LIMIT/OFFSET plus COUNT) with a parameterized filter; update is partial and builds its SET clause from a column allowlist, never from the payload; delete checks existence first. Every generated file already carries an oracle.'
     },
+    realtime: {
+      transports: ['GET /_synapse/sse/<topic> (event stream)', 'GET /_synapse/ws/<domain>/<name> (WebSocket upgrade)'],
+      rule: 'A topic must be declared with defineTopic({ name, owner, readRoles?, tenantId?, public? }) before anyone subscribes or publishes. Subscribing to an undeclared topic is refused; a topic declared only for another tenant is refused without disclosing that it exists; publishing into a topic the slice does not own is rejected and notifies nobody. Topics are namespaced per tenant. The WebSocket upgrade is refused unless the request carries a present origin matching SYNAPSE_ALLOWED_ORIGINS (or `*`), with a loopback-origin carve-out for local development. Both transports share one rate limiter and a per-client cap on concurrent connections.',
+      rejections: { ...REALTIME_REJECTIONS }
+    },
+    scaffolding: {
+      command:
+        'synapse new-slice <domain> <name> [--template=<template>] [--fields=<grammar>] · synapse new-shared <name> · synapse new <project>',
+      containment: `The domain, the slice name, the shared-module name and the new-project directory are each one safe path segment (pattern ${PATH_SEGMENT_PATTERN}), and before anything is written the resolved target is asserted to stay inside the directory the operation owns. A field name in --fields must be a plain identifier before it is interpolated into the generated DDL or TypeScript. Every containment failure is printed as JSON on standard output with a non-zero exit code.`,
+      failureCodes: { ...SCAFFOLD_FAILURE_CODES }
+    },
     gates: [
       {
         command: 'synapse check [arquivo]',

package/src/compiler/db-schema-generator.ts

@@ -129,20 +129,50 @@ function splitColumnDefinitions(body: string): string[] {
   return defs;
 }
 
+/** Index of the `)` matching the `(` at `openIndex`, or -1. Linear in the input. */
+function findMatchingParen(text: string, openIndex: number): number {
+  let depth = 0;
+
+  for (let index = openIndex; index < text.length; index++) {
+    const char = text[index];
+
+    if (char === '(') {
+      depth++;
+    } else if (char === ')') {
+      depth--;
+
+      if (depth === 0) {
+        return index;
+      }
+    }
+  }
+
+  return -1;
+}
+
 /**
  * Parses DDL string to extract all table and column definitions.
+ *
+ * The header is matched first and the column body is delimited by scanning for the
+ * matching parenthesis. The previous single-pattern form (`([\s\S]*?)\)(?:\s*;|\s*$)`)
+ * backtracked quadratically on a large DDL.
  */
 export function parseDdlToCatalog(ddl: string, sourceSlice?: string): TableDefinition[] {
   const tables: TableDefinition[] = [];
+  const createTableHeader = /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?["'`]?([a-zA-Z0-9_]+)["'`]?\s*\(/gi;
+
+  let header: RegExpExecArray | null = createTableHeader.exec(ddl);
 
-  // Match CREATE TABLE [IF NOT EXISTS] <name> (<columns>)
-  const createTableRegex =
-    /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?["'`]?([a-zA-Z0-9_]+)["'`]?\s*\(([\s\S]*?)\)(?:\s*;|\s*$)/gi;
+  while (header !== null) {
+    const openParen = header.index + header[0].length - 1;
+    const closeParen = findMatchingParen(ddl, openParen);
+
+    if (closeParen === -1) {
+      break;
+    }
 
-  let match: RegExpExecArray | null = createTableRegex.exec(ddl);
-  while (match !== null) {
-    const tableName = match[1].toLowerCase();
-    const body = match[2];
+    const tableName = header[1].toLowerCase();
+    const body = ddl.slice(openParen + 1, closeParen);
     const rawDefs = splitColumnDefinitions(body);
     const columns: ColumnDefinition[] = [];
 
@@ -202,7 +232,8 @@ export function parseDdlToCatalog(ddl: string, sourceSlice?: string): TableDefin
       sourceSlice
     });
 
-    match = createTableRegex.exec(ddl);
+    createTableHeader.lastIndex = closeParen + 1;
+    header = createTableHeader.exec(ddl);
   }
 
   return tables;

package/src/compiler/fields-parser.ts

@@ -6,6 +6,8 @@
  * DataForm/DataTable specs, and Fast-Check PBT test arbitraries.
  */
 
+import { Err, Ok, type Result } from '../core/machine-types';
+
 export type FieldType = 'string' | 'number' | 'integer' | 'boolean' | 'enum' | 'date' | 'timestamp' | 'json';
 
 export interface ParsedField {
@@ -17,6 +19,32 @@ export interface ParsedField {
   label: string;
 }
 
+/**
+ * Field and enum-value names are interpolated into generated DDL and generated
+ * TypeScript, so they must be plain identifiers before any code generation runs.
+ */
+const FIELD_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+
+/**
+ * Validates every field name (and enum value) in a parsed field list.
+ * Returns the first offending name as the error value.
+ */
+export function validateFieldNames(fields: ParsedField[]): Result<ParsedField[], string> {
+  for (const field of fields) {
+    if (!FIELD_NAME_PATTERN.test(field.name)) {
+      return Err(field.name);
+    }
+
+    for (const value of field.enumValues ?? []) {
+      if (!FIELD_NAME_PATTERN.test(value)) {
+        return Err(value);
+      }
+    }
+  }
+
+  return Ok(fields);
+}
+
 function fieldToLabel(name: string): string {
   return name
     .replace(/_/g, ' ')
@@ -173,7 +201,6 @@ export function generateSqlColumns(fields: ParsedField[]): string {
       case 'json':
       case 'string':
       case 'enum':
-      default:
         sqlType = 'TEXT';
         break;
     }

package/src/compiler/impact-analyzer.ts

@@ -24,7 +24,10 @@ export interface ImpactedSlice {
 }
 
 export interface ImpactAnalysisReport {
-  status: 'PASS';
+  status: 'PASS' | 'FAIL';
+  /** Present only when the target could not be resolved in this project. */
+  code?: 'TARGET_NOT_RESOLVED';
+  message?: string;
   operation: 'IMPACT_ANALYSIS';
   target: string;
   targetType: 'slice' | 'table' | 'shared_module';
@@ -156,6 +159,8 @@ export function analyzeImpact(target: string, rootDir: string = process.cwd()):
 
   const impactedMap = new Map<string, ImpactedSlice>();
 
+  let resolved = false;
+
   if (targetType === 'slice') {
     const targetSlice = sliceDataList.find(
       (s) =>
@@ -164,6 +169,8 @@ export function analyzeImpact(target: string, rootDir: string = process.cwd()):
         s.filePath.endsWith(`/${cleanTarget}`)
     );
 
+    resolved = Boolean(targetSlice);
+
     if (targetSlice) {
       impactedMap.set(targetSlice.sliceName, {
         sliceName: targetSlice.sliceName,
@@ -208,6 +215,10 @@ export function analyzeImpact(target: string, rootDir: string = process.cwd()):
   } else if (targetType === 'shared_module') {
     const sharedName = path.basename(cleanTarget, path.extname(cleanTarget));
 
+    resolved =
+      fs.existsSync(path.resolve(rootDir, cleanTarget)) ||
+      fs.existsSync(path.join(rootDir, 'src', 'shared', `${sharedName}.ts`));
+
     for (const slice of sliceDataList) {
       if (slice.sharedImports.includes(sharedName)) {
         impactedMap.set(slice.sliceName, {
@@ -223,6 +234,9 @@ export function analyzeImpact(target: string, rootDir: string = process.cwd()):
     // targetType === 'table'
     const tableName = cleanTarget.toLowerCase();
 
+    // A table exists in this project when some committed slice declares it.
+    resolved = sliceDataList.some((slice) => slice.tablesCreated.includes(tableName));
+
     for (const slice of sliceDataList) {
       if (slice.tablesCreated.includes(tableName)) {
         impactedMap.set(slice.sliceName, {
@@ -267,6 +281,22 @@ export function analyzeImpact(target: string, rootDir: string = process.cwd()):
     recommendedCommands.push('synapse test');
   }
 
+  if (!resolved) {
+    // An unresolvable target is a failure, not a successful empty result. Nothing
+    // was verified, so reporting PASS would be the same defect discovery refuses.
+    return {
+      status: 'FAIL',
+      code: 'TARGET_NOT_RESOLVED',
+      message: `Alvo '${cleanTarget}' não existe no projeto: nenhuma fatia, módulo compartilhado ou tabela corresponde.`,
+      operation: 'IMPACT_ANALYSIS',
+      target: cleanTarget,
+      targetType,
+      totalImpacted: 0,
+      impactedSlices: [],
+      recommendedCommands: []
+    };
+  }
+
   return {
     status: 'PASS',
     operation: 'IMPACT_ANALYSIS',