webspresso 0.0.99 → 0.0.100

package/index.d.ts

@@ -547,6 +547,19 @@ export interface CascadingLayoutInfo {
   configPath: string | null;
 }
 
+export interface CascadingErrorBoundaryInfo {
+  dirSegment: string;
+  errorRelPath: string;
+  fullPath: string;
+  configPath: string | null;
+}
+
+export interface CascadingLoadingInfo {
+  dirSegment: string;
+  loadingRelPath: string;
+  fullPath: string;
+}
+
 export namespace cascading {
   export function getDirectoryChain(relativeFilePath: string): string[];
   export function templateHasExtends(templateBody?: string | null, fullPath?: string): boolean;
@@ -568,6 +581,16 @@ export namespace cascading {
     renderContext: Record<string, unknown>,
     isDev?: boolean
   ): string;
+  export function findNearestErrorBoundary(
+    baseDir: string,
+    relativeFilePath: string,
+    isDev?: boolean
+  ): CascadingErrorBoundaryInfo | null;
+  export function findNearestLoadingTemplate(
+    baseDir: string,
+    relativeFilePath: string,
+    isDev?: boolean
+  ): CascadingLoadingInfo | null;
   export function clearCascadingCaches(): void;
 }
 
@@ -745,11 +768,20 @@ export interface ScopeContext {
 
 export type RelationType = 'belongsTo' | 'hasMany' | 'hasOne';
 
+export type RelationCascadeOption =
+  | boolean
+  | 'delete'
+  | 'restore'
+  | 'all'
+  | ('delete' | 'restore' | 'all')[]
+  | { delete?: boolean; restore?: boolean };
+
 export interface RelationDefinition {
   type: RelationType;
-  model: () => ModelDefinition;
+  model: string | (() => ModelDefinition<any> | string);
   foreignKey: string;
   localKey?: string;
+  cascade?: RelationCascadeOption;
 }
 
 export interface AdminPermissions {
@@ -955,6 +987,8 @@ export function hasModel(name: string): boolean;
 
 export function clearRegistry(): void;
 
+export function isCascadeEnabled(relation: RelationDefinition, operation: 'delete' | 'restore'): boolean;
+
 // --- ORM: schema & columns ---
 
 /** zdb column helpers (id, string, timestamp, …) + `schema()` */
@@ -1040,9 +1074,9 @@ export interface Repository<T = Record<string, any>> {
   createMany(data: (Partial<T> | Record<string, unknown>)[]): Promise<T[]>;
   update(id: string | number, data: Partial<T> | Record<string, unknown>): Promise<T | null>;
   updateWhere(conditions: Partial<T> | Record<string, unknown>, data: Partial<T> | Record<string, unknown>): Promise<number>;
-  delete(id: string | number): Promise<boolean>;
-  forceDelete(id: string | number): Promise<boolean>;
-  restore(id: string | number): Promise<T | null>;
+  delete(id: string | number, options?: { cascade?: boolean; deletedAt?: Date }): Promise<boolean>;
+  forceDelete(id: string | number, options?: { cascade?: boolean }): Promise<boolean>;
+  restore(id: string | number, options?: { cascade?: boolean; allChildren?: boolean }): Promise<T | null>;
   query(): QueryBuilder<T>;
   raw(sql: string, bindings?: unknown[]): Promise<unknown>;
   count(conditions?: Partial<T> | Record<string, unknown>): Promise<number>;
@@ -1795,6 +1829,82 @@ export interface ApiKeyRouteOptions {
 export function apiKeyPlugin(options?: ApiKeyPluginOptions): WebspressoPlugin;
 export function createApiKeyMiddleware(options?: ApiKeyPluginOptions & ApiKeyRouteOptions): RequestHandler;
 
+export interface WebhookEndpoint {
+  id?: number | string;
+  name: string;
+  url: string;
+  secret?: string;
+  events?: string[] | string;
+  is_active?: boolean;
+  description?: string | null;
+  headers?: Record<string, string> | string | null;
+  metadata?: Record<string, any> | string | null;
+  created_at?: Date | string;
+  updated_at?: Date | string;
+  [key: string]: any;
+}
+
+export interface WebhookDelivery {
+  id?: number | string;
+  endpoint_id: number | string;
+  event: string;
+  payload: string;
+  status_code?: number | null;
+  success: boolean;
+  duration_ms?: number | null;
+  error?: string | null;
+  response_body?: string | null;
+  attempt?: number;
+  max_attempts?: number;
+  next_retry_at?: Date | string | null;
+  created_at?: Date | string;
+  updated_at?: Date | string;
+  [key: string]: any;
+}
+
+export interface WebhooksPluginOptions {
+  db?: any;
+  knex?: any;
+  endpointsTable?: string;
+  deliveriesTable?: string;
+  maxAttempts?: number;
+  backoffBaseMs?: number;
+  timeoutMs?: number;
+  wrapPayload?: boolean;
+  queue?: any;
+  endpoints?: WebhookEndpoint[];
+  apiPrefix?: string;
+  includeDefaultPage?: boolean;
+  pageTitle?: string;
+  menuOrder?: number;
+}
+
+export interface WebhookDispatchResult {
+  dispatched: number;
+  deliveries: WebhookDelivery[];
+  results?: Array<{ success?: boolean; statusCode?: number; error?: string; [key: string]: any }>;
+}
+
+export interface WebhookDispatcherInstance {
+  dispatch(event: string, payload: any, options?: { wait?: boolean; endpointId?: number | string }): Promise<WebhookDispatchResult>;
+  pingEndpoint(endpointId: number | string): Promise<any>;
+  retryDelivery(deliveryId: number | string): Promise<any>;
+  createEndpoint(data: Partial<WebhookEndpoint>): Promise<WebhookEndpoint>;
+  getEndpoint(id: number | string): Promise<WebhookEndpoint | null>;
+  updateEndpoint(id: number | string, data: Partial<WebhookEndpoint>): Promise<WebhookEndpoint | null>;
+  deleteEndpoint(id: number | string): Promise<boolean>;
+  listEndpoints(filters?: { active?: boolean; search?: string; limit?: number; offset?: number }): Promise<WebhookEndpoint[]>;
+  listDeliveries(filters?: { endpointId?: number | string; event?: string; success?: boolean | string; page?: number; limit?: number }): Promise<{ items: WebhookDelivery[]; total: number; page: number; limit: number; pages: number }>;
+  getDelivery(id: number | string): Promise<WebhookDelivery | null>;
+  purgeDeliveries(options?: { days?: number }): Promise<number>;
+  dispose(): void;
+  on(event: string, listener: (...args: any[]) => void): this;
+}
+
+export function webhooksPlugin(options?: WebhooksPluginOptions): WebspressoPlugin & {
+  dispatcher: WebhookDispatcherInstance;
+};
+
 export interface ContentPluginOptions {
   db: import('./index').Database;
   adminPath?: string;
@@ -2283,8 +2393,11 @@ export interface QueueRetentionConfig {
 export interface ScheduleOptions {
   id?: string;
   overlap?: boolean;
+  preventOverlap?: boolean;
   maxRuns?: number;
   utc?: boolean;
+  timezone?: string;
+  tz?: string;
   runImmediately?: boolean;
   delay?: number | Date;
   attempts?: number;
@@ -2306,6 +2419,7 @@ export interface ScheduleInfo {
   nextRunAt: Date | null;
   isRunning: boolean;
   activeJobId: string | number | null;
+  activeJobIds?: (string | number)[];
   registeredAt: Date;
 }
 
@@ -2313,21 +2427,22 @@ export class CronExpression {
   rawExpression: string;
   resolvedExpression: string;
   utc: boolean;
+  timezone: string | null;
   minutes: Set<number>;
   hours: Set<number>;
   doms: Set<number>;
   months: Set<number>;
   dows: Set<number>;
-  constructor(expression: string, options?: { utc?: boolean });
-  match(date?: Date): boolean;
-  getNextDate(fromDate?: Date): Date | null;
-  getNextDates(count?: number, fromDate?: Date): Date[];
-  static isValid(expression: string): boolean;
-  static parse(expression: string, options?: { utc?: boolean }): CronExpression;
+  constructor(expression: string, options?: { utc?: boolean; timezone?: string; tz?: string });
+  match(date?: Date | string | number): boolean;
+  getNextDate(fromDate?: Date | string | number): Date | null;
+  getNextDates(count?: number, fromDate?: Date | string | number): Date[];
+  static isValid(expression: string, options?: { utc?: boolean; timezone?: string; tz?: string }): boolean;
+  static parse(expression: string, options?: { utc?: boolean; timezone?: string; tz?: string }): CronExpression;
 }
 
-export function parseCron(expression: string, options?: { utc?: boolean }): CronExpression;
-export function isValidCron(expression: string): boolean;
+export function parseCron(expression: string, options?: { utc?: boolean; timezone?: string; tz?: string }): CronExpression;
+export function isValidCron(expression: string, options?: { utc?: boolean; timezone?: string; tz?: string }): boolean;
 export function resolveCronAlias(str: string): string;
 export const CRON_ALIASES: Record<string, string>;
 
@@ -2345,6 +2460,8 @@ export class TaskScheduler {
   trigger(idOrJobName: string): Promise<Job | null>;
   start(): this;
   stop(): this;
+  pause(): this;
+  resume(): this;
   clear(): void;
   destroy(): void;
 }
@@ -2379,6 +2496,8 @@ export class QueueManager extends EventEmitter {
   unschedule(idOrJobName: string): boolean;
   getSchedules(): ScheduleInfo[];
   getSchedule(idOrJobName: string): ScheduleInfo | null;
+  triggerSchedule(idOrJobName: string): Promise<Job | null>;
+  triggerCron(idOrJobName: string): Promise<Job | null>;
   start(): this;
   pause(): this;
   resume(): this;
@@ -2453,14 +2572,20 @@ export interface HtmlStreamOptions {
   env: import('nunjucks').Environment;
   templatePath: string;
   context?: Record<string, unknown>;
-  defer?: Record<string, Promise<unknown> | { promise: Promise<unknown>; template?: string }>;
+  defer?: Record<string, Promise<unknown> | { promise: Promise<unknown>; template?: string; loadingTemplate?: string }>;
+  nonce?: string;
+  loadingTemplate?: string | null;
+  layouts?: CascadingLayoutInfo[];
 }
 
 export interface RenderStreamOptions {
   env?: import('nunjucks').Environment;
-  defer?: Record<string, Promise<unknown> | { promise: Promise<unknown>; template?: string }>;
+  defer?: Record<string, Promise<unknown> | { promise: Promise<unknown>; template?: string; loadingTemplate?: string }>;
   status?: number;
   flushImmediately?: boolean;
+  nonce?: string;
+  loadingTemplate?: string | null;
+  layouts?: CascadingLayoutInfo[];
 }
 
 export function createHtmlStream(options: HtmlStreamOptions): import('stream').Readable;
@@ -3155,10 +3280,145 @@ export namespace totp {
   };
 }
 
+// --- Magic Link / Passwordless Authentication ---
+
+export interface BuildMagicLinkUrlOptions {
+  baseUrl?: string;
+  path?: string;
+  token: string;
+}
+
+export interface FormatMagicLinkHtmlOptions {
+  name?: string;
+  magicLinkUrl: string;
+  expiresMinutes?: number;
+}
+
+export interface MagicLinkVerifyMiddlewareOptions {
+  tokenParam?: string;
+  redirectTo?: string;
+  failureRedirect?: string;
+  markEmailVerified?: boolean;
+  jwt?: boolean;
+}
 
+export interface MagicLinkRequestOptions {
+  baseUrl?: string;
+  path?: string;
+  tokenTtlMs?: number;
+  hideUserNotFound?: boolean;
+  buildMagicLinkUrl?: (token: string) => string;
+}
 
+export interface MagicLinkRequestResult {
+  sent: boolean;
+  userFound: boolean;
+  expiresAt?: Date;
+  token?: string;
+  magicLinkUrl?: string;
+}
 
+export interface MagicLinkVerifyResult {
+  ok: true;
+  user: any;
+  userId: string | number;
+  accessToken?: string;
+  refreshToken?: string;
+}
 
+export function buildMagicLinkUrl(options: BuildMagicLinkUrlOptions): string;
+export function formatMagicLinkHtml(options: FormatMagicLinkHtmlOptions): string;
+export function createMagicLinkVerifyMiddleware(authManager: any, options?: MagicLinkVerifyMiddlewareOptions): (req: any, res: any, next: any) => Promise<any>;
+export function createMagicLinkRequestHandler(authManager: any, options?: MagicLinkRequestOptions): (req: any, res: any) => Promise<any>;
 
+export namespace magicLink {
+  export {
+    buildMagicLinkUrl,
+    formatMagicLinkHtml,
+    createMagicLinkVerifyMiddleware,
+    createMagicLinkRequestHandler,
+  };
+}
+
+// Active Devices & Session Management
+export interface DeviceInfo {
+  browser: string;
+  os: string;
+  device: 'desktop' | 'mobile' | 'tablet' | 'bot' | 'unknown';
+  isMobile: boolean;
+  isTablet: boolean;
+  isDesktop: boolean;
+  isBot: boolean;
+}
 
+export interface UserSession {
+  id?: number | string;
+  session_id: string;
+  user_id: number | string;
+  ip_address?: string | null;
+  user_agent?: string | null;
+  browser?: string | null;
+  os?: string | null;
+  device?: string | null;
+  last_active_at: Date;
+  created_at?: Date;
+  is_current?: boolean;
+}
+
+export interface SessionTracker {
+  track(sessionId: string, userId: string | number, metadata?: { ip?: string; userAgent?: string; browser?: string; os?: string; device?: string }): Promise<UserSession | null>;
+  touch(sessionId: string): Promise<boolean>;
+  get(sessionId: string): Promise<UserSession | null>;
+  list(userId: string | number, currentSessionId?: string | null): Promise<UserSession[]>;
+  isSessionValid(sessionId: string, userId?: string | number | null): Promise<boolean>;
+  revoke(sessionId: string): Promise<boolean>;
+  revokeOthers(userId: string | number, currentSessionId?: string | null): Promise<number>;
+  revokeAll(userId: string | number): Promise<number>;
+  purgeExpired(maxAgeMs: number): Promise<number>;
+}
+
+export interface SessionManagerOptions {
+  tracker?: SessionTracker;
+  sessionStore?: any;
+  touchThrottleMs?: number;
+  emitter?: any;
+}
+
+export class SessionManager {
+  constructor(options?: SessionManagerOptions);
+  tracker: SessionTracker;
+  sessionStore?: any;
+  touchThrottleMs: number;
+  emitter?: any;
+  track(sessionId: string, userId: string | number, req?: any): Promise<UserSession | null>;
+  touch(sessionId: string): Promise<boolean>;
+  isSessionValid(sessionId: string, userId?: string | number | null): Promise<boolean>;
+  listSessions(userId: string | number, currentSessionId?: string | null): Promise<UserSession[]>;
+  revokeSession(sessionId: string, options?: { userId?: string | number; revokedBy?: string }): Promise<boolean>;
+  revokeOtherSessions(userId: string | number, currentSessionId: string): Promise<number>;
+  revokeAllSessions(userId: string | number): Promise<number>;
+}
+
+export function parseUserAgent(userAgent?: string): DeviceInfo;
+export function getClientIp(req?: any): string;
+export function createUserSessionsTable(knex: any): Promise<void>;
+export function dropUserSessionsTable(knex: any): Promise<void>;
+export function createKnexSessionTracker(db: any, options?: { tableName?: string }): SessionTracker;
+export function createMemorySessionTracker(): SessionTracker;
+export function createListSessionsHandler(authManager: any): (req: any, res: any) => Promise<any>;
+export function createRevokeSessionHandler(authManager: any): (req: any, res: any) => Promise<any>;
+
+export namespace sessions {
+  export {
+    SessionManager,
+    createUserSessionsTable,
+    dropUserSessionsTable,
+    createKnexSessionTracker,
+    createMemorySessionTracker,
+    getClientIp,
+    parseUserAgent,
+    createListSessionsHandler,
+    createRevokeSessionHandler,
+  };
+}
 

package/index.js

@@ -272,5 +272,9 @@ Object.defineProperties(module.exports, {
   createDevProfilerMiddleware: { get: () => require('./src/dev').createDevProfilerMiddleware, enumerable: true, configurable: true },
   generateTypes: { get: () => require('./src/dev/typegen').generateTypes, enumerable: true, configurable: true },
   typegen: { get: () => require('./src/dev/typegen'), enumerable: true, configurable: true },
+
+  // Webhooks plugin
+  webhooks: { get: () => require('./plugins/webhooks'), enumerable: true, configurable: true },
+  webhooksPlugin: { get: () => require('./plugins/webhooks').webhooksPlugin, enumerable: true, configurable: true },
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webspresso",
-  "version": "0.0.99",
+  "version": "0.0.100",
   "description": "Minimal, production-ready SSR framework for Node.js with file-based routing, Nunjucks templating, built-in i18n, and CLI tooling",
   "main": "index.js",
   "types": "index.d.ts",
@@ -126,7 +126,7 @@
     "nodemailer": "^10.0.10",
     "nunjucks": "^3.2.4",
     "sanitize-html": "^2.17.7",
-    "sharp": "^0.35.4",
+    "sharp": "^0.35.5",
     "swup": "^4.8.3",
     "yaml": "^2.8.3",
     "zod": "^3.23.0",
@@ -167,7 +167,7 @@
     "@types/node": "^20.14.0",
     "@vitest/coverage-v8": "^4.1.11",
     "better-sqlite3": "^11.10.0",
-    "chokidar": "^3.5.3",
+    "chokidar": "^4.0.3",
     "docboot": "^0.3.0",
     "dotenv": "^16.3.1",
     "express-rate-limit": "^8.4.1",
@@ -181,9 +181,11 @@
     "node": ">=20.0.0"
   },
   "overrides": {
-    "basic-ftp": "^5.3.0",
+    "basic-ftp": "^6.2.1",
+    "chokidar": "^4.0.3",
+    "katex": "^0.18.2",
     "tar": "^7.5.11",
-    "undici": "^6.24.0",
+    "undici": "^6.28.1",
     "uuid": "^11.1.1",
     "js-yaml": "^5.4.2",
     "qs": "^6.16.0"

package/plugins/admin-panel/modules/admin-users.js

@@ -692,7 +692,7 @@ const AdminUsersPage = {
                   m('input.w-full.px-3.py-2.border.border-gray-300.dark:border-slate-600.rounded-lg.bg-white.dark:bg-slate-900.text-gray-900.dark:text-slate-100.focus:ring-2.focus:ring-blue-500', {
                     type: 'text',
                     required: true,
-                    placeholder: 'e.g. Ahmet Yılmaz',
+                    placeholder: 'e.g. Jane Doe',
                     value: s.formName,
                     oninput: (e) => { s.formName = e.target.value; },
                   }),