@ismaelsoilet/synapsejs 1.3.0 → 1.8.0

package/src/core/cache.ts

@@ -0,0 +1,139 @@
+/**
+ * SynapseJS - Incremental Static Regeneration (ISR) & SSR Micro-Cache Contract
+ *
+ * Slices export `sliceCache` or `cacheConfig` to declare caching boundaries,
+ * stale-while-revalidate windows, and tag-based invalidation.
+ */
+
+export interface SliceCacheConfig {
+  /** Time to live in seconds before the cached SSR HTML is considered stale */
+  ttlSeconds: number;
+  /** Stale-while-revalidate grace period in seconds */
+  staleWhileRevalidateSeconds?: number;
+  /** Invalidation tags (e.g. ['products', 'catalog']) */
+  tags?: string[];
+  /** Allowed query parameters to differentiate cache entries (default: all non-tracking parameters) */
+  allowedParams?: string[];
+}
+
+/**
+ * Declares SSR caching and ISR revalidation policy for a slice.
+ */
+export function defineCache(config: SliceCacheConfig): SliceCacheConfig {
+  return config;
+}
+
+const DEFAULT_TRACKING_PARAMS = new Set([
+  'utm_source',
+  'utm_medium',
+  'utm_campaign',
+  'utm_term',
+  'utm_content',
+  'fbclid',
+  'gclid',
+  'msclkid',
+  'mc_eid',
+  '_ga',
+  '_gl',
+  'ref',
+  'v'
+]);
+
+/**
+ * Normalizes a URL into a deterministic SSR cache key:
+ * - Strips common ad/tracking query parameters (utm_*, fbclid, etc.)
+ * - If allowedParams is specified, filters query parameters strictly to that allowlist
+ * - Sorts query parameters deterministically to avoid duplicate cache entries for different key orders
+ */
+export function normalizeCacheKey(url: URL, allowedParams?: string[]): string {
+  const pathname = url.pathname;
+  const searchParams = new URLSearchParams(url.search);
+
+  const cleanParams = new URLSearchParams();
+  const allowedSet = allowedParams ? new Set(allowedParams) : null;
+
+  const sortedKeys = Array.from(searchParams.keys()).sort();
+  for (const key of sortedKeys) {
+    if (allowedSet) {
+      if (allowedSet.has(key)) {
+        for (const val of searchParams.getAll(key)) {
+          cleanParams.append(key, val);
+        }
+      }
+    } else if (!DEFAULT_TRACKING_PARAMS.has(key.toLowerCase()) && !key.toLowerCase().startsWith('utm_')) {
+      for (const val of searchParams.getAll(key)) {
+        cleanParams.append(key, val);
+      }
+    }
+  }
+
+  const queryStr = cleanParams.toString();
+  return queryStr ? `${pathname}?${queryStr}` : pathname;
+}
+
+/**
+ * In-memory Bounded LRU Cache with O(1) get/set and automatic eviction of least recently used entries.
+ */
+export class BoundedLruCache<V> {
+  private map = new Map<string, V>();
+  readonly maxEntries: number;
+
+  constructor(maxEntries = 1000) {
+    this.maxEntries = Math.max(1, maxEntries);
+  }
+
+  get(key: string): V | undefined {
+    const val = this.map.get(key);
+    if (val !== undefined) {
+      // Re-insert to mark as most recently used (MRU)
+      this.map.delete(key);
+      this.map.set(key, val);
+    }
+    return val;
+  }
+
+  set(key: string, value: V): void {
+    if (this.map.has(key)) {
+      this.map.delete(key);
+    } else if (this.map.size >= this.maxEntries) {
+      // Evict least recently used (first key in map iteration order)
+      const oldestKey = this.map.keys().next().value;
+      if (oldestKey !== undefined) {
+        this.map.delete(oldestKey);
+      }
+    }
+    this.map.set(key, value);
+  }
+
+  has(key: string): boolean {
+    return this.map.has(key);
+  }
+
+  delete(key: string): boolean {
+    return this.map.delete(key);
+  }
+
+  clear(): void {
+    this.map.clear();
+  }
+
+  get size(): number {
+    return this.map.size;
+  }
+
+  entries(): IterableIterator<[string, V]> {
+    return this.map.entries();
+  }
+
+  values(): IterableIterator<V> {
+    return this.map.values();
+  }
+
+  keys(): IterableIterator<string> {
+    return this.map.keys();
+  }
+
+  [Symbol.iterator](): IterableIterator<[string, V]> {
+    return this.map[Symbol.iterator]();
+  }
+}

package/src/core/config.ts

@@ -11,7 +11,7 @@ export interface SynapsePlugin {
   name: string;
   // biome-ignore lint/suspicious/noExplicitAny: generic boundary for framework server
   onBootstrap?: (server: any) => Promise<void> | void;
-  onRequest?: (req: Request) => Promise<Response | null | void> | Response | null | void;
+  onRequest?: (req: Request) => Promise<Response | null | undefined> | Response | null | void;
   onResponse?: (res: Response, req: Request) => Promise<Response> | Response;
   // biome-ignore lint/suspicious/noExplicitAny: generic boundary for database client
   onMigrate?: (db: any) => Promise<void> | void;
@@ -45,6 +45,42 @@ export interface SynapseConfig<TServices = Record<string, unknown>> {
    * Infrastructure lifecycle plugins (onBootstrap, onRequest, onResponse, onMigrate).
    */
   plugins?: SynapsePlugin[];
+
+  /**
+   * Compiler and client bundler configuration.
+   */
+  compiler?: {
+    vendorPackages?: string[];
+  };
+
+  /**
+   * Trust proxy headers (cf-connecting-ip, x-forwarded-for) for rate limiting and IP resolution.
+   */
+  trustProxy?: boolean;
+
+  /**
+   * Max allowed payload bytes for RPC POST requests (default: 5MB).
+   */
+  maxRpcPayloadBytes?: number;
+
+  /**
+   * Max allowed payload bytes for Webhook POST requests (default: 10MB).
+   */
+  maxWebhookPayloadBytes?: number;
+
+  /**
+   * SSR Cache settings.
+   */
+  cache?: {
+    maxEntries?: number;
+  };
+
+  /**
+   * Image optimizer security settings.
+   */
+  imageOptimizer?: {
+    allowedDomains?: string[];
+  };
 }
 
 export function defineConfig<TServices = Record<string, unknown>>(

package/src/core/index.ts

@@ -1,4 +1,6 @@
 export * from './action-context';
+export * from './action-definition';
+export * from './cache';
 export * from './config';
 export * from './database-client';
 export * from './database-factory';
@@ -13,3 +15,4 @@ export * from './session-token';
 export * from './sqlite-client';
 export * from './storage';
 export * from './validation';
+export * from './websocket';

package/src/core/postgres-client.ts

@@ -21,6 +21,7 @@ import {
 export class PostgresDatabaseClient implements DatabaseClient {
   private client: postgres.Sql;
 
+  // biome-ignore lint/suspicious/noExplicitAny: external postgres.js options boundary
   constructor(connectionString: string, options?: postgres.Options<any>) {
     this.client = postgres(connectionString, {
       max: options?.max || 10,
@@ -34,6 +35,7 @@ export class PostgresDatabaseClient implements DatabaseClient {
 
   async query<T = unknown>(queryStr: string, params: unknown[] = []): Promise<T[]> {
     // postgres.js unsafe executes raw SQL with parameter bindings
+    // biome-ignore lint/suspicious/noExplicitAny: external postgres.js unsafe bindings boundary
     const result = await this.client.unsafe(queryStr, params as any[]);
     return result as unknown as T[];
   }
@@ -97,20 +99,24 @@ export class PostgresDatabaseClient implements DatabaseClient {
     const res = await this.client.begin(async (sqlTx) => {
       const txClient: DatabaseClient = {
         query: async <U = unknown>(q: string, p: unknown[] = []) => {
+          // biome-ignore lint/suspicious/noExplicitAny: external postgres.js unsafe bindings boundary
           const res = await sqlTx.unsafe(q, p as any[]);
           return res as unknown as U[];
         },
         queryOne: async <U = unknown>(q: string, p: unknown[] = []) => {
+          // biome-ignore lint/suspicious/noExplicitAny: external postgres.js unsafe bindings boundary
           const res = await sqlTx.unsafe(q, p as any[]);
           return (res[0] ?? null) as U | null;
         },
         sql: async <U = unknown>(strings: TemplateStringsArray, ...values: unknown[]) => {
           const { text, params } = compileTaggedSql(strings, ...values);
+          // biome-ignore lint/suspicious/noExplicitAny: external postgres.js unsafe bindings boundary
           const res = await sqlTx.unsafe(text, params as any[]);
           return res as unknown as U[];
         },
         sqlOne: async <U = unknown>(strings: TemplateStringsArray, ...values: unknown[]) => {
           const { text, params } = compileTaggedSql(strings, ...values);
+          // biome-ignore lint/suspicious/noExplicitAny: external postgres.js unsafe bindings boundary
           const res = await sqlTx.unsafe(text, params as any[]);
           return (res[0] ?? null) as U | null;
         },

package/src/core/postgres-queue.ts

@@ -136,9 +136,29 @@ export class PostgresQueueEngine {
     const now = Date.now();
     const staleThreshold = now - this.visibilityTimeoutMs;
 
+    // 1. Mover tarefas zumbi expiradas para a tabela de DLQ
+    const deadJobs = await this.db.query<JobRecord>(
+      `UPDATE _synapse_jobs
+       SET status = 'dlq', locked_at = NULL, updated_at = $1, last_error = 'Visibility timeout exceeded max attempts'
+       WHERE status = 'running' AND locked_at < $2 AND attempts >= max_attempts
+       RETURNING *;`,
+      [now, staleThreshold]
+    );
+
+    for (const deadJob of deadJobs) {
+      await this.db
+        .query(
+          `INSERT INTO _synapse_jobs_dlq (id, name, payload, attempts, max_attempts, last_error, failed_at)
+           VALUES ($1, $2, $3, $4, $5, $6, $7)
+           ON CONFLICT (id) DO UPDATE SET attempts = EXCLUDED.attempts, last_error = EXCLUDED.last_error, failed_at = EXCLUDED.failed_at;`,
+          [deadJob.id, deadJob.name, deadJob.payload, deadJob.attempts, deadJob.max_attempts, deadJob.last_error, now]
+        )
+        .catch(() => {});
+    }
+
     const rows = await this.db.query<JobRecord>(
       `UPDATE _synapse_jobs
-       SET status = 'running', locked_at = $1, updated_at = $1
+       SET status = 'running', locked_at = $1, updated_at = $1, attempts = attempts + 1
        WHERE id = (
          SELECT id FROM _synapse_jobs
          WHERE (status = 'pending' AND run_at <= $1)
@@ -201,8 +221,8 @@ export class PostgresQueueEngine {
       await this.db.query(
         `UPDATE _synapse_jobs
          SET status = 'completed', attempts = $1, locked_at = NULL, updated_at = $2, last_error = NULL
-         WHERE id = $3`,
-        [attempts, now, job.id]
+         WHERE id = $3 AND (locked_at = $4 OR locked_at IS NULL)`,
+        [attempts, now, job.id, job.locked_at]
       );
       return true;
     } catch (handlerErr: unknown) {
@@ -218,8 +238,8 @@ export class PostgresQueueEngine {
         await this.db.query(
           `UPDATE _synapse_jobs
            SET status = 'pending', attempts = $1, run_at = $2, locked_at = NULL, updated_at = $3, last_error = $4
-           WHERE id = $5`,
-          [attempts, nextRunAt, now, errorMsg, job.id]
+           WHERE id = $5 AND (locked_at = $6 OR locked_at IS NULL)`,
+          [attempts, nextRunAt, now, errorMsg, job.id, job.locked_at]
         );
       } else {
         await this.sendToDlq(job, attempts, `Esgotado limite de tentativas (${job.max_attempts}): ${errorMsg}`, now);
@@ -244,8 +264,8 @@ export class PostgresQueueEngine {
     await this.db.query(
       `UPDATE _synapse_jobs
        SET status = 'dlq', attempts = $1, locked_at = NULL, updated_at = $2, last_error = $3
-       WHERE id = $4`,
-      [attempts, now, errorMsg, job.id]
+       WHERE id = $4 AND (locked_at = $5 OR locked_at IS NULL)`,
+      [attempts, now, errorMsg, job.id, job.locked_at]
     );
 
     this.logger.warn(`[DLQ] Job ${job.name} (${job.id}) movido para Dead Letter Queue: ${dlqId}`);

package/src/core/query-builder.ts

@@ -56,6 +56,31 @@ export function sanitizeIdentifier(ident: string): string {
   return trimmed;
 }
 
+const VALID_WHERE_OPERATORS = new Set<string>([
+  '=',
+  '!=',
+  '<>',
+  '>',
+  '<',
+  '>=',
+  '<=',
+  'LIKE',
+  'ILIKE',
+  'IN',
+  'NOT IN',
+  'IS NULL',
+  'IS NOT NULL',
+  'BETWEEN'
+]);
+
+export function sanitizeOperator(op: string): WhereOperator {
+  const normalized = op.trim().toUpperCase();
+  if (!VALID_WHERE_OPERATORS.has(normalized)) {
+    throw new Error(`Invalid SQL operator: "${op}"`);
+  }
+  return normalized as WhereOperator;
+}
+
 /** Normalize WhereCondition into an array of WhereClauseItem */
 function normalizeWhere(where?: WhereCondition): WhereClauseItem[] {
   if (!where) return [];
@@ -70,6 +95,13 @@ function normalizeWhere(where?: WhereCondition): WhereClauseItem[] {
       items.push({ column, op: 'IS NULL' });
     } else if (Array.isArray(value)) {
       items.push({ column, op: 'IN', value });
+    } else if (typeof value === 'object' && value !== null && 'op' in value) {
+      const cond = value as { op: string; val?: unknown; value?: unknown };
+      items.push({
+        column,
+        op: cond.op as WhereOperator,
+        value: cond.val !== undefined ? cond.val : cond.value
+      });
     } else {
       items.push({ column, op: '=', value });
     }
@@ -77,6 +109,46 @@ function normalizeWhere(where?: WhereCondition): WhereClauseItem[] {
   return items;
 }
 
+/** Compiles WhereClauseItem array into parameterized SQL condition strings */
+export function compileWhereClauses(whereItems: WhereClauseItem[], params: unknown[]): string[] {
+  const conditions: string[] = [];
+
+  for (const item of whereItems) {
+    const col = sanitizeIdentifier(item.column);
+    const op = sanitizeOperator(item.op);
+
+    if (op === 'IS NULL' || op === 'IS NOT NULL') {
+      conditions.push(`${col} ${op}`);
+    } else if (op === 'IN' || op === 'NOT IN') {
+      const arr = Array.isArray(item.value) ? item.value : [item.value];
+      if (arr.length === 0) {
+        conditions.push(op === 'IN' ? '1=0' : '1=1');
+      } else {
+        const placeholders = arr.map((val) => {
+          params.push(val);
+          return `$${params.length}`;
+        });
+        conditions.push(`${col} ${op} (${placeholders.join(', ')})`);
+      }
+    } else if (op === 'BETWEEN') {
+      const arr = Array.isArray(item.value) ? item.value : [];
+      if (arr.length !== 2) {
+        throw new Error(`BETWEEN operator requires an array of 2 values, received: ${JSON.stringify(item.value)}`);
+      }
+      params.push(arr[0]);
+      const p1 = `$${params.length}`;
+      params.push(arr[1]);
+      const p2 = `$${params.length}`;
+      conditions.push(`${col} BETWEEN ${p1} AND ${p2}`);
+    } else {
+      params.push(item.value);
+      conditions.push(`${col} ${op} $${params.length}`);
+    }
+  }
+
+  return conditions;
+}
+
 /**
  * Maps flat prefixed columns (e.g. "customer_name") into nested objects ({ customer: { name } })
  */
@@ -174,42 +246,7 @@ export function compileSelect(table: string, options?: QueryOptions): { sql: str
   // 2. WHERE clause
   const whereItems = normalizeWhere(options?.where);
   if (whereItems.length > 0) {
-    const conditions: string[] = [];
-
-    for (const item of whereItems) {
-      const col = sanitizeIdentifier(item.column);
-      const op = item.op.toUpperCase() as WhereOperator;
-
-      if (op === 'IS NULL' || op === 'IS NOT NULL') {
-        conditions.push(`${col} ${op}`);
-      } else if (op === 'IN' || op === 'NOT IN') {
-        const arr = Array.isArray(item.value) ? item.value : [item.value];
-        if (arr.length === 0) {
-          // Empty IN clause: IN () is invalid SQL -> false / true condition
-          conditions.push(op === 'IN' ? '1=0' : '1=1');
-        } else {
-          const placeholders = arr.map((val) => {
-            params.push(val);
-            return `$${params.length}`;
-          });
-          conditions.push(`${col} ${op} (${placeholders.join(', ')})`);
-        }
-      } else if (op === 'BETWEEN') {
-        const arr = Array.isArray(item.value) ? item.value : [];
-        if (arr.length !== 2) {
-          throw new Error(`BETWEEN operator requires an array of 2 values, received: ${JSON.stringify(item.value)}`);
-        }
-        params.push(arr[0]);
-        const p1 = `$${params.length}`;
-        params.push(arr[1]);
-        const p2 = `$${params.length}`;
-        conditions.push(`${col} BETWEEN ${p1} AND ${p2}`);
-      } else {
-        params.push(item.value);
-        conditions.push(`${col} ${op} $${params.length}`);
-      }
-    }
-
+    const conditions = compileWhereClauses(whereItems, params);
     if (conditions.length > 0) {
       sql += ` WHERE ${conditions.join(' AND ')}`;
     }
@@ -299,18 +336,7 @@ export function compileUpdate(
     throw new Error(`Unconditional UPDATE on ${table} is blocked for safety. Provide a WHERE condition.`);
   }
 
-  const conditions: string[] = [];
-  for (const item of whereItems) {
-    const col = sanitizeIdentifier(item.column);
-    const op = item.op.toUpperCase() as WhereOperator;
-    if (op === 'IS NULL' || op === 'IS NOT NULL') {
-      conditions.push(`${col} ${op}`);
-    } else {
-      params.push(item.value);
-      conditions.push(`${col} ${op} $${params.length}`);
-    }
-  }
-
+  const conditions = compileWhereClauses(whereItems, params);
   sql += ` WHERE ${conditions.join(' AND ')} RETURNING *;`;
   return { sql, params };
 }
@@ -326,18 +352,7 @@ export function compileDelete(table: string, where: WhereCondition): { sql: stri
   }
 
   const params: unknown[] = [];
-  const conditions: string[] = [];
-  for (const item of whereItems) {
-    const col = sanitizeIdentifier(item.column);
-    const op = item.op.toUpperCase() as WhereOperator;
-    if (op === 'IS NULL' || op === 'IS NOT NULL') {
-      conditions.push(`${col} ${op}`);
-    } else {
-      params.push(item.value);
-      conditions.push(`${col} ${op} $${params.length}`);
-    }
-  }
-
+  const conditions = compileWhereClauses(whereItems, params);
   const sql = `DELETE FROM ${safeTable} WHERE ${conditions.join(' AND ')} RETURNING *;`;
   return { sql, params };
 }

package/src/core/session-context.ts

@@ -79,7 +79,7 @@ export function requireTenant(session?: SessionContext, expectedTenantId?: strin
     return Err('UNAUTHORIZED');
   }
 
-  if (expectedTenantId && session.tenantId && session.tenantId !== expectedTenantId) {
+  if (expectedTenantId && session.tenantId !== expectedTenantId) {
     return Err('FORBIDDEN');
   }
 

package/src/core/session-token.ts

@@ -17,6 +17,7 @@ import { Err, Ok, type Result } from './machine-types';
 export interface SessionClaims {
   userId: string;
   roles: string[];
+  tenantId?: string;
   /** Expiry, in seconds since the epoch. */
   exp: number;
 }
@@ -118,7 +119,7 @@ function constantTimeEquals(left: string, right: string): boolean {
 }
 
 export function signSessionToken(
-  claims: { userId: string; roles: string[] },
+  claims: { userId: string; roles: string[]; tenantId?: string },
   secret: string,
   maxAgeSeconds = 86_400
 ): string {
@@ -126,6 +127,7 @@ export function signSessionToken(
     JSON.stringify({
       userId: claims.userId,
       roles: claims.roles,
+      tenantId: claims.tenantId,
       exp: Math.floor(Date.now() / 1000) + maxAgeSeconds
     })
   );
@@ -162,6 +164,10 @@ export function verifySessionToken(
     return Err('INVALID_TOKEN');
   }
 
+  if (claims.tenantId !== undefined && typeof claims.tenantId !== 'string') {
+    return Err('INVALID_TOKEN');
+  }
+
   if (claims.exp * 1000 < Date.now()) {
     return Err('EXPIRED_TOKEN');
   }

package/src/core/sqlite-client.ts

@@ -38,6 +38,7 @@ export class SqliteDatabaseClient implements DatabaseClient {
   private statements: Map<string, Statement<unknown, SQLQueryBindings[]>> = new Map();
   private maxStatements: number;
   private txLock: Promise<void> = Promise.resolve();
+  private txDepth = 0;
 
   constructor(filePath?: string, maxStatements = 500) {
     this.maxStatements = maxStatements;
@@ -53,6 +54,11 @@ export class SqliteDatabaseClient implements DatabaseClient {
     }
 
     this.db.run('PRAGMA journal_mode = WAL;');
+    this.db.run('PRAGMA synchronous = NORMAL;');
+    this.db.run('PRAGMA busy_timeout = 5000;');
+    this.db.run('PRAGMA temp_store = MEMORY;');
+    this.db.run('PRAGMA cache_size = -64000;');
+    this.db.run('PRAGMA mmap_size = 268435456;');
     this.db.run('PRAGMA foreign_keys = ON;');
   }
 
@@ -161,6 +167,22 @@ export class SqliteDatabaseClient implements DatabaseClient {
   }
 
   async transaction<T>(operation: (tx: DatabaseClient) => Promise<T>): Promise<T> {
+    if (this.txDepth > 0) {
+      // Reentrant transaction: use SQLite SAVEPOINT
+      const spId = `sp_${++this.txDepth}`;
+      this.db.run(`SAVEPOINT ${spId};`);
+      try {
+        const result = await operation(this);
+        this.db.run(`RELEASE SAVEPOINT ${spId};`);
+        return result;
+      } catch (err) {
+        this.db.run(`ROLLBACK TO SAVEPOINT ${spId};`);
+        throw err;
+      } finally {
+        this.txDepth--;
+      }
+    }
+
     let releaseLock: () => void = () => {};
     const lockAcquired = new Promise<void>((resolve) => {
       releaseLock = resolve;
@@ -172,7 +194,8 @@ export class SqliteDatabaseClient implements DatabaseClient {
     await previousLock;
 
     try {
-      this.db.run('BEGIN TRANSACTION;');
+      this.txDepth = 1;
+      this.db.run('BEGIN IMMEDIATE TRANSACTION;');
       try {
         const result = await operation(this);
         this.db.run('COMMIT;');
@@ -180,6 +203,8 @@ export class SqliteDatabaseClient implements DatabaseClient {
       } catch (err) {
         this.db.run('ROLLBACK;');
         throw err;
+      } finally {
+        this.txDepth = 0;
       }
     } finally {
       releaseLock();

package/src/core/storage.ts

@@ -219,11 +219,7 @@ export class S3StorageAdapter implements StorageClient {
     });
 
     if (!response.ok && response.status !== 200 && response.status !== 204) {
-      if (response.status === 403 || response.status === 404) {
-        // Fallback for mock/test environments
-      } else {
-        throw new Error(`Storage upload failed with HTTP status ${response.status}`);
-      }
+      throw new Error(`Storage upload failed with HTTP status ${response.status}`);
     }
 
     return {

package/src/core/websocket.ts

@@ -0,0 +1,30 @@
+/**
+ * SynapseJS - Native Bidirectional WebSocket Abstraction
+ *
+ * Provides a type-safe contract for real-time duplex communication
+ * seamlessly integrated with native Bun.serve WebSockets.
+ */
+
+export interface SynapseWebSocket<TServerMsg = unknown> {
+  readonly id: string;
+  readonly sliceKey: string;
+  send(message: TServerMsg | string): void;
+  close(code?: number, reason?: string): void;
+  data: Record<string, unknown>;
+}
+
+export interface SliceSocketDefinition<TClientMsg = unknown, TServerMsg = unknown> {
+  onOpen?: (ws: SynapseWebSocket<TServerMsg>) => void | Promise<void>;
+  onMessage: (ws: SynapseWebSocket<TServerMsg>, message: TClientMsg) => void | Promise<void>;
+  onClose?: (ws: SynapseWebSocket<TServerMsg>, code: number, reason: string) => void | Promise<void>;
+}
+
+/**
+ * Declares a bidirectional WebSocket endpoint for a slice.
+ * Automatically discovered and mounted at `GET /_synapse/ws/:domain/:name`.
+ */
+export function defineSocket<TClientMsg = unknown, TServerMsg = unknown>(
+  def: SliceSocketDefinition<TClientMsg, TServerMsg>
+): SliceSocketDefinition<TClientMsg, TServerMsg> {
+  return def;
+}

package/src/index.ts

@@ -65,7 +65,13 @@ export {
   parseOracleJunit,
   runSliceOracles
 } from './compiler/oracle-runner';
-export { type ScaffoldError, type ScaffoldErrorCode, scaffoldCrud, scaffoldSlice } from './compiler/scaffolder';
+export {
+  type ScaffoldError,
+  type ScaffoldErrorCode,
+  scaffoldCrud,
+  scaffoldShared,
+  scaffoldSlice
+} from './compiler/scaffolder';
 export { orderSlicesByDag, parseTableDependencies } from './compiler/schema-dag';
 export {
   checkSchemaDrift,
@@ -130,4 +136,5 @@ export {
   type SliceMetadata,
   SynapseServer
 } from './runtime/server';
+export { SYNAPSE_VERSION } from './version';
 export { fc };