@stacksjs/stx 0.1.16 → 0.2.3

package/dist/csp.d.ts

@@ -0,0 +1,229 @@
+import type { CspConfig, CspDirectives, CspPreset, CustomDirective, StxOptions } from './types';
+/**
+ * Generate a cryptographically secure nonce for CSP
+ *
+ * @param length - Length of nonce in bytes (default 16)
+ * @returns Base64-encoded nonce string
+ *
+ * @example
+ * ```typescript
+ * const nonce = generateNonce()
+ * // Returns something like: "4AiRXmSkM+XRG3E2Y1fO9Q=="
+ * ```
+ */
+export declare function generateNonce(length?: number): string;
+/**
+ * Get or create a nonce for the current request context
+ *
+ * Uses WeakMap to ensure nonce is request-scoped and can be garbage collected.
+ * If no context is provided, generates a new nonce each time.
+ *
+ * @param context - Request context object for nonce scoping
+ * @param config - CSP configuration (may include custom nonce generator)
+ * @returns The nonce for the current context
+ *
+ * @example
+ * ```typescript
+ * // In a request handler
+ * const ctx = { requestId: '123' }
+ * const nonce = getNonce(ctx, cspConfig)
+ * // Same nonce returned for same context object
+ * const sameNonce = getNonce(ctx, cspConfig)
+ * ```
+ */
+export declare function getNonce(context?: object, config?: CspConfig): string;
+/**
+ * Clear the nonce for a context (useful for testing or manual cleanup)
+ *
+ * @param context - Request context to clear nonce for
+ */
+export declare function clearNonce(context: object): void;
+/**
+ * Generate a CSP header string from directive configuration
+ *
+ * @param directives - CSP directive configuration
+ * @param nonce - Optional nonce to inject into script-src and style-src
+ * @returns CSP header string
+ *
+ * @example
+ * ```typescript
+ * const header = generateCspHeader({
+ *   'default-src': ["'self'"],
+ *   'script-src': ["'self'", 'https://cdn.example.com'],
+ *   'upgrade-insecure-requests': true,
+ * })
+ * // Returns: "default-src 'self'; script-src 'self' https://cdn.example.com; upgrade-insecure-requests"
+ * ```
+ */
+export declare function generateCspHeader(directives: CspDirectives, nonce?: string): string;
+/**
+ * Generate CSP meta tag HTML
+ *
+ * @param directives - CSP directive configuration
+ * @param nonce - Optional nonce to inject
+ * @returns HTML meta tag string
+ *
+ * @example
+ * ```typescript
+ * const metaTag = generateCspMetaTag({
+ *   'default-src': ["'self'"],
+ * })
+ * // Returns: '<meta http-equiv="Content-Security-Policy" content="default-src \'self\'">'
+ * ```
+ */
+export declare function generateCspMetaTag(directives: CspDirectives, nonce?: string): string;
+/**
+ * Get a CSP preset configuration by name
+ *
+ * @param preset - Name of the preset
+ * @returns CSP configuration object
+ *
+ * @example
+ * ```typescript
+ * const config = getCspPreset('strict')
+ * // Returns full CspConfig with strict directives
+ * ```
+ */
+export declare function getCspPreset(preset: CspPreset): CspConfig;
+/**
+ * Merge two CSP directive configurations
+ *
+ * Sources from the second config are added to the first.
+ * Boolean directives are OR'd together.
+ *
+ * @param base - Base CSP directives
+ * @param override - Override/additional directives
+ * @returns Merged CSP directives
+ *
+ * @example
+ * ```typescript
+ * const merged = mergeCspDirectives(
+ *   { 'default-src': ["'self'"], 'script-src': ["'self'"] },
+ *   { 'script-src': ['https://cdn.example.com'], 'img-src': ['https:'] }
+ * )
+ * // Result: {
+ * //   'default-src': ["'self'"],
+ * //   'script-src': ["'self'", "https://cdn.example.com"],
+ * //   'img-src': ["https:"]
+ * // }
+ * ```
+ */
+export declare function mergeCspDirectives(base: CspDirectives, override: CspDirectives): CspDirectives;
+/**
+ * Inject CSP meta tag into HTML head
+ *
+ * @param html - HTML content
+ * @param config - CSP configuration
+ * @param context - Request context for nonce scoping
+ * @returns HTML with CSP meta tag injected
+ */
+export declare function injectCspMetaTag(html: string, config: CspConfig, context?: object): string;
+/**
+ * Add nonce attribute to all inline script and style tags
+ *
+ * @param html - HTML content
+ * @param nonce - Nonce value to add
+ * @returns HTML with nonce attributes added
+ */
+export declare function addNonceToInlineContent(html: string, nonce: string): string;
+/**
+ * Process CSP-related directives in templates
+ *
+ * Handles:
+ * - @csp - Insert CSP meta tag
+ * - @cspNonce - Output current nonce value
+ *
+ * @param template - Template content
+ * @param context - Template context
+ * @param _filePath - Source file path
+ * @param options - STX options
+ * @returns Processed template
+ */
+export declare function processCspDirectives(template: string, context: Record<string, any>, _filePath: string, options: StxOptions): string;
+/**
+ * Register CSP-related custom directives
+ *
+ * @returns Array of custom directives for CSP
+ */
+export declare function registerCspDirectives(): CustomDirective[];
+/**
+ * Validate CSP directive configuration
+ *
+ * @param directives - CSP directives to validate
+ * @returns Array of validation warnings
+ *
+ * @example
+ * ```typescript
+ * const warnings = validateCspDirectives({
+ *   'script-src': ["'unsafe-inline'", "'unsafe-eval'"],
+ * })
+ * // Returns warnings about unsafe usage
+ * ```
+ */
+export declare function validateCspDirectives(directives: CspDirectives): string[];
+/**
+ * Get the appropriate CSP header name based on configuration
+ *
+ * @param reportOnly - Whether to use report-only mode
+ * @returns Header name string
+ */
+export declare function getCspHeaderName(reportOnly?: boolean): string;
+/**
+ * Create CSP headers object for HTTP response
+ *
+ * @param config - CSP configuration
+ * @param context - Request context for nonce scoping
+ * @returns Headers object ready to spread into response
+ *
+ * @example
+ * ```typescript
+ * const headers = createCspHeaders(cspConfig, requestContext)
+ * return new Response(body, { headers: { ...headers } })
+ * ```
+ */
+export declare function createCspHeaders(config: CspConfig, context?: object): Record<string, string>;
+/**
+ * Strict CSP preset - Maximum security, may require nonces for inline content
+ *
+ * - No unsafe-inline or unsafe-eval
+ * - Uses strict-dynamic for scripts
+ * - Blocks object/embed
+ * - Restricts form actions to same origin
+ */
+export declare const strictCspPreset: CspDirectives;
+/**
+ * Moderate CSP preset - Balanced security and compatibility
+ *
+ * - Allows unsafe-inline for styles (common requirement)
+ * - Blocks unsafe-eval
+ * - Allows data: URIs for images
+ */
+export declare const moderateCspPreset: CspDirectives;
+/**
+ * Relaxed CSP preset - Basic protection, maximum compatibility
+ *
+ * - Allows unsafe-inline for both scripts and styles
+ * - Still blocks unsafe-eval and object embeds
+ */
+export declare const relaxedCspPreset: CspDirectives;
+/**
+ * API-only CSP preset - For JSON API responses
+ *
+ * - Blocks all content loading (APIs shouldn't render HTML)
+ * - Prevents framing
+ */
+export declare const apiCspPreset: CspDirectives;
+/**
+ * CSP meta tag directive
+ * Usage: @csp
+ */
+export declare const cspDirective: CustomDirective;
+/**
+ * CSP nonce directive
+ * Usage: @cspNonce
+ */
+export declare const cspNonceDirective: CustomDirective;
+/**
+ * Default CSP configuration - moderate preset
+ */
+export declare const defaultCspConfig: CspConfig;

package/dist/database.d.ts

@@ -0,0 +1,407 @@
+import type { StxOptions } from './types';
+/**
+ * Configure database connections
+ *
+ * @param config - Database configuration
+ *
+ * @example
+ * configureDatabase({
+ *   default: 'sqlite',
+ *   connections: {
+ *     sqlite: { driver: 'sqlite', database: './database.db' }
+ *   }
+ * })
+ */
+export declare function configureDatabase(config: Partial<DatabaseConfig>): void;
+/**
+ * Get current database configuration
+ */
+export declare function getDatabaseConfig(): DatabaseConfig;
+/**
+ * Reset database configuration to defaults
+ */
+export declare function resetDatabaseConfig(): void;
+/**
+ * Register a custom database adapter
+ *
+ * @param name - Connection name
+ * @param adapter - Database adapter instance
+ */
+export declare function registerAdapter(name: string, adapter: DatabaseAdapter): void;
+/**
+ * Get database adapter for connection
+ *
+ * @param connection - Connection name (defaults to default connection)
+ */
+export declare function getAdapter(connection?: string): DatabaseAdapter;
+/**
+ * Create a new query builder for a table
+ *
+ * @param table - Table name
+ * @returns Query builder instance
+ *
+ * @example
+ * const users = await query('users')
+ *   .where('active', true)
+ *   .orderBy('name')
+ *   .get()
+ */
+export declare function query(table: string): QueryBuilder;
+/**
+ * Alias for query()
+ */
+export declare function table(name: string): QueryBuilder;
+/**
+ * Create a raw SQL expression
+ */
+export declare function raw(sql: string, bindings?: unknown[]): RawExpression;
+/**
+ * Define a model
+ *
+ * @param name - Model name
+ * @param definition - Model definition
+ * @returns Model instance
+ *
+ * @example
+ * const User = defineModel('User', {
+ *   table: 'users',
+ *   primaryKey: 'id',
+ *   fillable: ['name', 'email'],
+ *   hidden: ['password'],
+ *   relationships: {
+ *     posts: { type: 'hasMany', model: 'Post', foreignKey: 'user_id' }
+ *   }
+ * })
+ */
+export declare function defineModel(name: string, definition: ModelDefinition): Model;
+/**
+ * Get a registered model by name
+ */
+export declare function getModel(name: string): Model;
+/**
+ * Check if a model is registered
+ */
+export declare function hasModel(name: string): boolean;
+/**
+ * Run a callback within a transaction
+ *
+ * @param callback - Function to run within transaction
+ * @param connection - Optional connection name
+ *
+ * @example
+ * await transaction(async () => {
+ *   await query('users').insert({ name: 'John' })
+ *   await query('profiles').insert({ user_id: 1, bio: 'Hello' })
+ * })
+ */
+export declare function transaction<T>(callback: () => Promise<T>, connection?: string): Promise<T>;
+/**
+ * Clear all query cache
+ */
+export declare function clearQueryCache(): void;
+/**
+ * Get query cache statistics
+ */
+export declare function getQueryCacheStats(): { size: number, keys: string[] };
+/**
+ * Get query log
+ */
+export declare function getQueryLog(): typeof queryLog;
+/**
+ * Clear query log
+ */
+export declare function clearQueryLog(): void;
+/**
+ * Enable or disable query logging
+ */
+export declare function enableQueryLogging(enabled?: boolean): void;
+/**
+ * Process @db directive in templates
+ *
+ * Syntax: @db('table')->method()->method()
+ *
+ * @example
+ * @db('users')->where('active', true)->get()
+ * @db('posts')->orderBy('created_at', 'desc')->limit(5)->get()
+ */
+export declare function processDbDirective(template: string, context: Record<string, any>, _filePath: string, _options: StxOptions): Promise<string>;
+/**
+ * Process @model directive in templates
+ *
+ * Syntax: @model('ModelName')->method()
+ *
+ * @example
+ * @model('User')->find(1)
+ * @model('Post')->where('published', true)->get()
+ */
+export declare function processModelDirective(template: string, context: Record<string, any>, _filePath: string, _options: StxOptions): Promise<string>;
+/**
+ * Process @query directive for inline SQL
+ *
+ * Syntax: @query('SELECT * FROM users WHERE id = ?', [1])
+ */
+export declare function processQueryDirective(template: string, context: Record<string, any>, _filePath: string, _options: StxOptions): Promise<string>;
+/**
+ * Process all database-related directives in a template
+ */
+export declare function processDatabaseDirectives(template: string, context: Record<string, any>, filePath: string, options: StxOptions): Promise<string>;
+/**
+ * Get schema builder
+ */
+export declare function schema(): SchemaBuilder;
+/**
+ * Database connection configuration
+ */
+export declare interface ConnectionConfig {
+  driver: DatabaseDriver
+  database: string
+  host?: string
+  port?: number
+  username?: string
+  password?: string
+  poolSize?: number
+  timeout?: number
+  ssl?: boolean | Record<string, unknown>
+  options?: Record<string, unknown>
+}
+/**
+ * Database configuration
+ */
+export declare interface DatabaseConfig {
+  default: string
+  connections: Record<string, ConnectionConfig>
+  logging?: boolean
+  cacheTTL?: number
+  maxCacheSize?: number
+}
+/**
+ * Where clause condition
+ */
+export declare interface WhereCondition {
+  column: string
+  operator: QueryOperator
+  value: unknown
+  boolean: 'and' | 'or'
+}
+/**
+ * Order by clause
+ */
+export declare interface OrderByClause {
+  column: string
+  direction: 'asc' | 'desc'
+}
+/**
+ * Join clause
+ */
+export declare interface JoinClause {
+  type: 'inner' | 'left' | 'right' | 'cross'
+  table: string
+  first: string
+  operator: string
+  second: string
+}
+/**
+ * Raw SQL expression
+ */
+export declare interface RawExpression {
+  __raw: true
+  sql: string
+  bindings: unknown[]
+}
+/**
+ * Relationship definition
+ */
+export declare interface RelationshipDefinition {
+  type: 'hasOne' | 'hasMany' | 'belongsTo' | 'belongsToMany'
+  model: string
+  foreignKey?: string
+  localKey?: string
+  pivotTable?: string
+  pivotForeignKey?: string
+  pivotRelatedKey?: string
+}
+/**
+ * Model definition
+ */
+export declare interface ModelDefinition {
+  table: string
+  primaryKey?: string
+  fillable?: string[]
+  hidden?: string[]
+  timestamps?: { createdAt?: string, updatedAt?: string } | boolean
+  softDeletes?: string | boolean
+  defaults?: Record<string, unknown>
+  casts?: Record<string, 'string' | 'number' | 'boolean' | 'date' | 'json' | 'array'>
+  relationships?: Record<string, RelationshipDefinition>
+  scopes?: Record<string, (query: QueryBuilder) => QueryBuilder>
+}
+/**
+ * Model instance
+ */
+export declare interface ModelInstance {
+  get: (key: string) => unknown
+  set: (key: string, value: unknown) => void
+  toJSON: () => Row
+  save: () => Promise<void>
+  delete: () => Promise<void>
+  refresh: () => Promise<void>
+  exists: boolean
+  original: Row
+  attributes: Row
+  isDirty: (key?: string) => boolean
+}
+/**
+ * Model class
+ */
+export declare interface Model {
+  name: string
+  definition: ModelDefinition
+  find: (id: unknown) => Promise<ModelInstance | null>
+  findOrFail: (id: unknown) => Promise<ModelInstance>
+  all: () => Promise<ModelInstance[]>
+  create: (attributes: Row) => Promise<ModelInstance>
+  update: (attributes: Row) => Promise<number>
+  destroy: (ids: unknown | unknown[]) => Promise<number>
+  query: () => QueryBuilder
+  where: (column: string, operatorOrValue: QueryOperator | unknown, value?: unknown) => QueryBuilder
+  first: () => Promise<ModelInstance | null>
+  get: () => Promise<ModelInstance[]>
+  count: () => Promise<number>
+}
+/**
+ * Database adapter interface
+ */
+export declare interface DatabaseAdapter {
+  connect: () => Promise<void>
+  disconnect: () => Promise<void>
+  query: <T = Row>(sql: string, bindings?: unknown[]) => Promise<T[]>
+  insert: (sql: string, bindings?: unknown[]) => Promise<unknown>
+  execute: (sql: string, bindings?: unknown[]) => Promise<number>
+  beginTransaction: () => Promise<void>
+  commit: () => Promise<void>
+  rollback: () => Promise<void>
+  isConnected: () => boolean
+}
+/**
+ * Supported database drivers
+ */
+export type DatabaseDriver = 'sqlite' | 'postgres' | 'mysql' | 'custom'
+/**
+ * Query operator types
+ */
+export type QueryOperator = '=' | '!=' | '<' | '<=' | '>' | '>=' | 'like' | 'in' | 'not in' | 'between' | 'is null' | 'is not null'
+/**
+ * Query result row
+ */
+export type Row = Record<string, unknown>
+/**
+ * Fluent query builder class
+ */
+export declare class QueryBuilder {
+  private _table: string;
+  private _columns: (string | RawExpression)[];
+  private _wheres: WhereCondition[];
+  private _orders: OrderByClause[];
+  private _joins: JoinClause[];
+  private _groupBy: string[];
+  private _having: WhereCondition[];
+  private _limit?: number;
+  private _offset?: number;
+  private _distinct: boolean;
+  private _connection?: string;
+  private _bindings: unknown[];
+  private _modelDefinition?: ModelDefinition;
+  constructor(table?: string);
+  table(name: string): this;
+  from(name: string): this;
+  connection(name: string): this;
+  select(columns: (string | RawExpression)[]): this;
+  addSelect(columns: (string | RawExpression)[]): this;
+  distinct(): this;
+  where(column: string, operatorOrValue: QueryOperator | unknown, value?: unknown): this;
+  orWhere(column: string, operatorOrValue: QueryOperator | unknown, value?: unknown): this;
+  whereIn(column: string, values: unknown[]): this;
+  whereNotIn(column: string, values: unknown[]): this;
+  whereNull(column: string): this;
+  whereNotNull(column: string): this;
+  whereBetween(column: string, min: unknown, max: unknown): this;
+  whereLike(column: string, pattern: string): this;
+  join(table: string, first: string, operator: string, second: string): this;
+  leftJoin(table: string, first: string, operator: string, second: string): this;
+  rightJoin(table: string, first: string, operator: string, second: string): this;
+  orderBy(column: string, direction?: 'asc' | 'desc'): this;
+  orderByDesc(column: string): this;
+  groupBy(columns: string[]): this;
+  having(column: string, operator: QueryOperator, value: unknown): this;
+  limit(count: number): this;
+  take(count: number): this;
+  offset(count: number): this;
+  skip(count: number): this;
+  forPage(page: number, perPage?: number): this;
+  get(): Promise<Row[]>;
+  first(): Promise<Row | null>;
+  firstOrFail(): Promise<Row>;
+  find(id: unknown, primaryKey?: string): Promise<Row | null>;
+  value(column: string): Promise<unknown>;
+  pluck(column: string): Promise<unknown[]>;
+  exists(): Promise<boolean>;
+  doesntExist(): Promise<boolean>;
+  count(column?: string): Promise<number>;
+  max(column: string): Promise<number | null>;
+  min(column: string): Promise<number | null>;
+  sum(column: string): Promise<number>;
+  avg(column: string): Promise<number | null>;
+  insert(data: Row): Promise<unknown>;
+  insertAll(rows: Row[]): Promise<void>;
+  update(data: Row): Promise<number>;
+  increment(column: string, amount?: number): Promise<number>;
+  decrement(column: string, amount?: number): Promise<number>;
+  delete(): Promise<number>;
+  truncate(): Promise<void>;
+  toSql(): { sql: string, bindings: unknown[] };
+  private buildWhereClause(): string;
+  private getCacheKey(sql: string, bindings: unknown[]): string;
+  clone(): QueryBuilder;
+}
+/**
+ * Database error with query context
+ */
+export declare class DatabaseError extends Error {
+  public sql?: string;
+  public bindings?: unknown[];
+  constructor(message: string, sql?: string, bindings?: unknown[]);
+}
+/**
+ * Schema builder for database migrations
+ */
+export declare class SchemaBuilder {
+  private _connection?: string;
+  connection(name: string): this;
+  create(table: string, callback: (blueprint: Blueprint) => void): Promise<void>;
+  drop(table: string): Promise<void>;
+  rename(from: string, to: string): Promise<void>;
+  hasTable(table: string): Promise<boolean>;
+}
+/**
+ * Table blueprint for schema definitions
+ */
+export declare class Blueprint {
+  private columns: string[];
+  private indices: string[];
+  private table: string;
+  constructor(table: string);
+  id(name?: string): this;
+  string(name: string, length?: number): this;
+  text(name: string): this;
+  integer(name: string): this;
+  boolean(name: string): this;
+  datetime(name: string): this;
+  timestamps(): this;
+  softDeletes(): this;
+  json(name: string): this;
+  foreignId(name: string): this;
+  index(columns: string | string[]): this;
+  unique(columns: string | string[]): this;
+  toCreateSQL(): string;
+  getIndexSQL(): string[];
+}

package/dist/database.js

@@ -0,0 +1,5 @@
+// @bun
+var Q=import.meta.require;var $={default:"sqlite",connections:{},logging:!1,cacheTTL:0,maxCacheSize:1000},V={},A={},L=new Map,S=[];function o(z){$={...$,...z}}function r(){return{...$}}function a(){$={default:"sqlite",connections:{},logging:!1,cacheTTL:0,maxCacheSize:1000};for(let z of Object.keys(V))delete V[z];L.clear(),S.length=0}function t(z,H){V[z]=H}function F(z){let H=z||$.default;if(V[H])return V[H];let U=$.connections[H];if(!U)throw Error(`Database connection "${H}" not configured`);let W=h(U);return V[H]=W,W}function h(z){switch(z.driver){case"sqlite":return q(z);case"postgres":return y(z);case"mysql":return f(z);default:throw Error(`Unsupported database driver: ${z.driver}`)}}function q(z){let H=null,U=!1;return{async connect(){if(U)return;let{Database:W}=await import("bun:sqlite");H=new W(z.database,{create:!0,readwrite:!0}),U=!0},async disconnect(){if(H)H.close(),H=null,U=!1},async query(W,J=[]){if(!U)await this.connect();let X=performance.now();try{let Y=H.prepare(W).all(...J);if($.logging)B(W,J,performance.now()-X);return Y}catch(Z){throw new O(`Query failed: ${Z}`,W,J)}},async insert(W,J=[]){if(!U)await this.connect();let X=performance.now();try{let Y=H.prepare(W).run(...J);if($.logging)B(W,J,performance.now()-X);return Y.lastInsertRowid}catch(Z){throw new O(`Insert failed: ${Z}`,W,J)}},async execute(W,J=[]){if(!U)await this.connect();let X=performance.now();try{let Y=H.prepare(W).run(...J);if($.logging)B(W,J,performance.now()-X);return Y.changes}catch(Z){throw new O(`Execute failed: ${Z}`,W,J)}},async beginTransaction(){if(!U)await this.connect();H.run("BEGIN TRANSACTION")},async commit(){H.run("COMMIT")},async rollback(){H.run("ROLLBACK")},isConnected(){return U}}}function y(z){let H=!1,U=null;return{async connect(){if(H)return;try{let{Client:W}=await import("pg");U=new W({host:z.host||"localhost",port:z.port||5432,database:z.database,user:z.username,password:z.password,ssl:z.ssl}),await U.connect(),H=!0}catch(W){throw Error(`PostgreSQL connection failed. Install 'pg' package: ${W}`)}},async disconnect(){if(U)await U.end(),U=null,H=!1},async query(W,J=[]){if(!H)await this.connect();let X=performance.now();try{let Z=await U.query(W,J);if($.logging)B(W,J,performance.now()-X);return Z.rows}catch(Z){throw new O(`Query failed: ${Z}`,W,J)}},async insert(W,J=[]){if(!H)await this.connect();let X=performance.now();try{let Z=await U.query(`${W} RETURNING id`,J);if($.logging)B(W,J,performance.now()-X);return Z.rows[0]?.id}catch(Z){throw new O(`Insert failed: ${Z}`,W,J)}},async execute(W,J=[]){if(!H)await this.connect();let X=performance.now();try{let Z=await U.query(W,J);if($.logging)B(W,J,performance.now()-X);return Z.rowCount||0}catch(Z){throw new O(`Execute failed: ${Z}`,W,J)}},async beginTransaction(){if(!H)await this.connect();await U.query("BEGIN")},async commit(){await U.query("COMMIT")},async rollback(){await U.query("ROLLBACK")},isConnected(){return H}}}function f(z){let H=!1,U=null;return{async connect(){if(H)return;try{U=(await import("mysql2/promise")).createPool({host:z.host||"localhost",port:z.port||3306,database:z.database,user:z.username,password:z.password,waitForConnections:!0,connectionLimit:z.poolSize||10,queueLimit:0}),H=!0}catch(W){throw Error(`MySQL connection failed. Install 'mysql2' package: ${W}`)}},async disconnect(){if(U)await U.end(),U=null,H=!1},async query(W,J=[]){if(!H)await this.connect();let X=performance.now();try{let[Z]=await U.execute(W,J);if($.logging)B(W,J,performance.now()-X);return Z}catch(Z){throw new O(`Query failed: ${Z}`,W,J)}},async insert(W,J=[]){if(!H)await this.connect();let X=performance.now();try{let[Z]=await U.execute(W,J);if($.logging)B(W,J,performance.now()-X);return Z.insertId}catch(Z){throw new O(`Insert failed: ${Z}`,W,J)}},async execute(W,J=[]){if(!H)await this.connect();let X=performance.now();try{let[Z]=await U.execute(W,J);if($.logging)B(W,J,performance.now()-X);return Z.affectedRows||0}catch(Z){throw new O(`Execute failed: ${Z}`,W,J)}},async beginTransaction(){if(!H)await this.connect();let W=await U.getConnection();return await W.beginTransaction(),W},async commit(){await U.execute("COMMIT")},async rollback(){await U.execute("ROLLBACK")},isConnected(){return H}}}class D{_table="";_columns=["*"];_wheres=[];_orders=[];_joins=[];_groupBy=[];_having=[];_limit;_offset;_distinct=!1;_connection;_bindings=[];_modelDefinition;constructor(z){if(z)this._table=z}table(z){return this._table=z,this}from(z){return this.table(z)}connection(z){return this._connection=z,this}select(...z){return this._columns=z.length>0?z:["*"],this}addSelect(...z){if(this._columns[0]==="*")this._columns=z;else this._columns.push(...z);return this}distinct(){return this._distinct=!0,this}where(z,H,U){let W="=",J=H;if(U!==void 0)W=H,J=U;return this._wheres.push({column:z,operator:W,value:J,boolean:"and"}),this}orWhere(z,H,U){let W="=",J=H;if(U!==void 0)W=H,J=U;return this._wheres.push({column:z,operator:W,value:J,boolean:"or"}),this}whereIn(z,H){return this._wheres.push({column:z,operator:"in",value:H,boolean:"and"}),this}whereNotIn(z,H){return this._wheres.push({column:z,operator:"not in",value:H,boolean:"and"}),this}whereNull(z){return this._wheres.push({column:z,operator:"is null",value:null,boolean:"and"}),this}whereNotNull(z){return this._wheres.push({column:z,operator:"is not null",value:null,boolean:"and"}),this}whereBetween(z,H,U){return this._wheres.push({column:z,operator:"between",value:[H,U],boolean:"and"}),this}whereLike(z,H){return this._wheres.push({column:z,operator:"like",value:H,boolean:"and"}),this}join(z,H,U,W){return this._joins.push({type:"inner",table:z,first:H,operator:U,second:W}),this}leftJoin(z,H,U,W){return this._joins.push({type:"left",table:z,first:H,operator:U,second:W}),this}rightJoin(z,H,U,W){return this._joins.push({type:"right",table:z,first:H,operator:U,second:W}),this}orderBy(z,H="asc"){return this._orders.push({column:z,direction:H}),this}orderByDesc(z){return this.orderBy(z,"desc")}groupBy(...z){return this._groupBy.push(...z),this}having(z,H,U){return this._having.push({column:z,operator:H,value:U,boolean:"and"}),this}limit(z){return this._limit=z,this}take(z){return this.limit(z)}offset(z){return this._offset=z,this}skip(z){return this.offset(z)}forPage(z,H=15){return this.offset((z-1)*H).limit(H)}async get(){let{sql:z,bindings:H}=this.toSql();if($.cacheTTL&&$.cacheTTL>0){let J=this.getCacheKey(z,H),X=g(J);if(X!==void 0)return X}let W=await F(this._connection).query(z,H);if($.cacheTTL&&$.cacheTTL>0){let J=this.getCacheKey(z,H);m(J,W,$.cacheTTL)}return W}async first(){return(await this.limit(1).get())[0]||null}async firstOrFail(){let z=await this.first();if(!z)throw Error("No results found");return z}async find(z,H="id"){return this.where(H,z).first()}async value(z){let H=await this.select(z).first();return H?H[z]:null}async pluck(z){return(await this.select(z).get()).map((U)=>U[z])}async exists(){return(await this.select(E("1")).limit(1).get()).length>0}async doesntExist(){return!await this.exists()}async count(z="*"){let H=await this.select(E(`COUNT(${z}) as count`)).first();return Number(H?.count||0)}async max(z){return(await this.select(E(`MAX(${z}) as max`)).first())?.max}async min(z){return(await this.select(E(`MIN(${z}) as min`)).first())?.min}async sum(z){let H=await this.select(E(`SUM(${z}) as sum`)).first();return Number(H?.sum||0)}async avg(z){return(await this.select(E(`AVG(${z}) as avg`)).first())?.avg}async insert(z){let H=Object.keys(z),U=H.map(()=>"?").join(", "),W=Object.values(z),J=`INSERT INTO ${this._table} (${H.join(", ")}) VALUES (${U})`,X=F(this._connection);return P(this._table),X.insert(J,W)}async insertAll(z){if(z.length===0)return;let H=Object.keys(z[0]),U=z.map(()=>`(${H.map(()=>"?").join(", ")})`).join(", "),W=z.flatMap((Z)=>Object.values(Z)),J=`INSERT INTO ${this._table} (${H.join(", ")}) VALUES ${U}`,X=F(this._connection);P(this._table),await X.execute(J,W)}async update(z){this._bindings=[];let H=this.buildWhereClause(),U=[...this._bindings],W=Object.keys(z).map((Y)=>`${Y} = ?`).join(", "),J=[...Object.values(z),...U],X=`UPDATE ${this._table} SET ${W}${H}`,Z=F(this._connection);return P(this._table),Z.execute(X,J)}async increment(z,H=1){this._bindings=[];let U=this.buildWhereClause(),W=`UPDATE ${this._table} SET ${z} = ${z} + ?${U}`,J=F(this._connection);return P(this._table),J.execute(W,[H,...this._bindings])}async decrement(z,H=1){return this.increment(z,-H)}async delete(){this._bindings=[];let z=this.buildWhereClause(),H=`DELETE FROM ${this._table}${z}`,U=F(this._connection);return P(this._table),U.execute(H,this._bindings)}async truncate(){let z=F(this._connection);P(this._table),await z.execute(`DELETE FROM ${this._table}`)}toSql(){this._bindings=[];let z="SELECT ";if(this._distinct)z+="DISTINCT ";z+=this._columns.map((H)=>{if(typeof H==="object"&&H.__raw)return H.sql;return H}).join(", "),z+=` FROM ${this._table}`;for(let H of this._joins)z+=` ${H.type.toUpperCase()} JOIN ${H.table} ON ${H.first} ${H.operator} ${H.second}`;if(z+=this.buildWhereClause(),this._groupBy.length>0)z+=` GROUP BY ${this._groupBy.join(", ")}`;if(this._having.length>0){let H=this._having.map((U,W)=>{let J=W===0?"":` ${U.boolean.toUpperCase()} `;return this._bindings.push(U.value),`${J}${U.column} ${U.operator} ?`});z+=` HAVING ${H.join("")}`}if(this._orders.length>0)z+=` ORDER BY ${this._orders.map((H)=>`${H.column} ${H.direction.toUpperCase()}`).join(", ")}`;if(this._limit!==void 0)z+=` LIMIT ${this._limit}`;if(this._offset!==void 0)z+=` OFFSET ${this._offset}`;return{sql:z,bindings:this._bindings}}buildWhereClause(){if(this._wheres.length===0)return"";return this._wheres.map((H,U)=>{let W=U===0?" WHERE ":` ${H.boolean.toUpperCase()} `;switch(H.operator){case"in":{let J=H.value,X=J.map(()=>"?").join(", ");return this._bindings.push(...J),`${W}${H.column} IN (${X})`}case"not in":{let J=H.value,X=J.map(()=>"?").join(", ");return this._bindings.push(...J),`${W}${H.column} NOT IN (${X})`}case"between":{let[J,X]=H.value;return this._bindings.push(J,X),`${W}${H.column} BETWEEN ? AND ?`}case"is null":return`${W}${H.column} IS NULL`;case"is not null":return`${W}${H.column} IS NOT NULL`;default:return this._bindings.push(H.value),`${W}${H.column} ${H.operator} ?`}}).join("")}getCacheKey(z,H){return`${this._table}:${z}:${JSON.stringify(H)}`}clone(){let z=new D(this._table);return z._columns=[...this._columns],z._wheres=[...this._wheres],z._orders=[...this._orders],z._joins=[...this._joins],z._groupBy=[...this._groupBy],z._having=[...this._having],z._limit=this._limit,z._offset=this._offset,z._distinct=this._distinct,z._connection=this._connection,z}}function G(z){return new D(z)}function n(z){return G(z)}function E(z,H=[]){return{__raw:!0,sql:z,bindings:H}}function e(z,H){let U=H.primaryKey||"id",W={name:z,definition:H,async find(J){let X=await G(H.table).where(U,J).first();return X?N(W,X):null},async findOrFail(J){let X=await this.find(J);if(!X)throw Error(`${z} not found with ${U} = ${J}`);return X},async all(){return(await G(H.table).get()).map((X)=>N(W,X))},async create(J){let X={...H.defaults,...J},Z=H.fillable?Object.fromEntries(Object.entries(X).filter(([_])=>H.fillable.includes(_))):X;if(H.timestamps!==!1){let _=new Date().toISOString(),R=typeof H.timestamps==="object"?H.timestamps.createdAt||"created_at":"created_at",T=typeof H.timestamps==="object"?H.timestamps.updatedAt||"updated_at":"updated_at";Z[R]=_,Z[T]=_}let Y=await G(H.table).insert(Z);return this.findOrFail(Y)},async update(J){return G(H.table).update(J)},async destroy(J){let X=Array.isArray(J)?J:[J];return G(H.table).whereIn(U,X).delete()},query(){return G(H.table)},where(J,X,Z){return this.query().where(J,X,Z)},async first(){let J=await this.query().first();return J?N(W,J):null},async get(){return(await this.query().get()).map((X)=>N(W,X))},async count(){return this.query().count()}};return A[z]=W,W}function k(z){let H=A[z];if(!H)throw Error(`Model "${z}" not defined. Use defineModel() first.`);return H}function zz(z){return z in A}function N(z,H){let{definition:U}=z,W=U.primaryKey||"id",J={...H},X={...H};if(U.casts){for(let[Y,_]of Object.entries(U.casts))if(Y in X)X[Y]=p(X[Y],_)}let Z={exists:!0,original:J,attributes:X,get(Y){return X[Y]},set(Y,_){X[Y]=_},toJSON(){let Y={...X};if(U.hidden)for(let _ of U.hidden)delete Y[_];return Y},async save(){let Y={};for(let _ of Object.keys(X))if(X[_]!==J[_])Y[_]=X[_];if(Object.keys(Y).length>0){if(U.timestamps!==!1){let _=typeof U.timestamps==="object"?U.timestamps.updatedAt||"updated_at":"updated_at";Y[_]=new Date().toISOString()}await G(U.table).where(W,J[W]).update(Y),Object.assign(J,Y)}},async delete(){if(U.softDeletes){let Y=typeof U.softDeletes==="string"?U.softDeletes:"deleted_at";await G(U.table).where(W,J[W]).update({[Y]:new Date().toISOString()})}else await G(U.table).where(W,J[W]).delete();Z.exists=!1},async refresh(){let Y=await G(U.table).where(W,J[W]).first();if(Y)Object.assign(J,Y),Object.assign(X,Y)},isDirty(Y){if(Y)return X[Y]!==J[Y];return Object.keys(X).some((_)=>X[_]!==J[_])}};if(U.relationships)for(let[Y,_]of Object.entries(U.relationships))Object.defineProperty(Z,Y,{value:async()=>{return b(Z,_,z)},enumerable:!1});return new Proxy(Z,{get(Y,_){if(_ in Y)return Y[_];return X[_]},set(Y,_,R){if(_ in Y)Y[_]=R;else X[_]=R;return!0}})}async function b(z,H,U){let W=k(H.model),J=U.definition.primaryKey||"id";switch(H.type){case"hasOne":{let X=H.foreignKey||`${U.name.toLowerCase()}_id`,Z=await G(W.definition.table).where(X,z.get(J)).first();return Z?N(W,Z):null}case"hasMany":{let X=H.foreignKey||`${U.name.toLowerCase()}_id`;return(await G(W.definition.table).where(X,z.get(J)).get()).map((Y)=>N(W,Y))}case"belongsTo":{let X=H.foreignKey||`${H.model.toLowerCase()}_id`,Z=H.localKey||"id",Y=await G(W.definition.table).where(Z,z.get(X)).first();return Y?N(W,Y):null}case"belongsToMany":{let X=H.pivotTable||[U.name,H.model].sort().join("_").toLowerCase(),Z=H.pivotForeignKey||`${U.name.toLowerCase()}_id`,Y=H.pivotRelatedKey||`${H.model.toLowerCase()}_id`,_=W.definition.primaryKey||"id";return(await G(W.definition.table).join(X,`${W.definition.table}.${_}`,"=",`${X}.${Y}`).where(`${X}.${Z}`,z.get(J)).get()).map((T)=>N(W,T))}default:return null}}function p(z,H){if(z===null||z===void 0)return z;switch(H){case"string":return String(z);case"number":return Number(z);case"boolean":return Boolean(z);case"date":return new Date(z);case"json":case"array":return typeof z==="string"?JSON.parse(z):z;default:return z}}async function Hz(z,H){let U=F(H);await U.beginTransaction();try{let W=await z();return await U.commit(),W}catch(W){throw await U.rollback(),W}}function g(z){let H=L.get(z);if(!H)return;if(Date.now()-H.timestamp>H.ttl*1000){L.delete(z);return}return H.result}function m(z,H,U){if(L.size>=($.maxCacheSize||1000)){let W=L.keys().next().value;if(W)L.delete(W)}L.set(z,{result:H,timestamp:Date.now(),ttl:U})}function P(z){for(let H of L.keys())if(H.startsWith(`${z}:`))L.delete(H)}function Jz(){L.clear()}function Uz(){return{size:L.size,keys:[...L.keys()]}}function B(z,H,U){if(S.push({sql:z,bindings:H,duration:U,timestamp:new Date}),S.length>1000)S.shift()}function Wz(){return[...S]}function Xz(){S.length=0}function Yz(z=!0){$.logging=z}class O extends Error{sql;bindings;constructor(z,H,U){super(z);this.sql=H;this.bindings=U;this.name="DatabaseError"}}async function u(z,H,U,W){let J=/@db\(\s*['"]([^'"]+)['"]\s*\)((?:->\w+\([^)]*\))*)/g,X=z,Z=[...z.matchAll(J)];for(let Y of Z){let[_,R,T]=Y;try{let j=await s(R,T),I=`$${R}`;H[I]=j,X=X.replace(_,"")}catch(j){X=X.replace(_,`<!-- DB Error: ${j instanceof Error?j.message:String(j)} -->`)}}return X}async function d(z,H,U,W){let J=/@model\(\s*['"]([^'"]+)['"]\s*\)((?:->\w+\([^)]*\))*)/g,X=z,Z=[...z.matchAll(J)];for(let Y of Z){let[_,R,T]=Y;try{let j=k(R),I=await l(j,T),K=`$${R.toLowerCase()}`;H[K]=I,X=X.replace(_,"")}catch(j){X=X.replace(_,`<!-- Model Error: ${j instanceof Error?j.message:String(j)} -->`)}}return X}async function c(z,H,U,W){let J=/@query\(\s*['"]([^'"]+)['"]\s*(?:,\s*(\[[^\]]*\]))?\s*\)\s*as\s+\$(\w+)/g,X=z,Z=[...z.matchAll(J)];for(let Y of Z){let[_,R,T,j]=Y;try{let I=T?JSON.parse(T):[],v=await F().query(R,I);H[`$${j}`]=v,X=X.replace(_,"")}catch(I){X=X.replace(_,`<!-- Query Error: ${I instanceof Error?I.message:String(I)} -->`)}}return X}async function s(z,H){let U=G(z),W=/->(\w+)\(([^)]*)\)/g,J=[...H.matchAll(W)],X=U;for(let[,Z,Y]of J){let _=M(Y);if(typeof X[Z]==="function"){if(X=X[Z](..._),X instanceof Promise){X=await X;break}}}if(X instanceof D)X=await X.get();return X}async function l(z,H){let U=/->(\w+)\(([^)]*)\)/g,W=[...H.matchAll(U)],J=z;for(let[,X,Z]of W){let Y=M(Z);if(typeof J[X]==="function"){if(J=J[X](...Y),J instanceof Promise)J=await J}else if(J instanceof D){if(typeof J[X]==="function"){if(J=J[X](...Y),J instanceof Promise)J=await J}}}if(J instanceof D)J=await J.get();return J}function M(z){if(!z.trim())return[];let H=[],U="",W=0,J=!1,X="";for(let Z=0;Z<z.length;Z++){let Y=z[Z];if(!J&&(Y==='"'||Y==="'"))J=!0,X=Y,U+=Y;else if(J&&Y===X)J=!1,U+=Y;else if(!J&&(Y==="["||Y==="{"||Y==="("))W++,U+=Y;else if(!J&&(Y==="]"||Y==="}"||Y===")"))W--,U+=Y;else if(!J&&W===0&&Y===",")H.push(x(U.trim())),U="";else U+=Y}if(U.trim())H.push(x(U.trim()));return H}function x(z){if(z.startsWith('"')&&z.endsWith('"')||z.startsWith("'")&&z.endsWith("'"))return z.slice(1,-1);if(z==="true")return!0;if(z==="false")return!1;if(z==="null")return null;let H=Number(z);if(!Number.isNaN(H))return H;try{return JSON.parse(z)}catch{return z}}async function Zz(z,H,U,W){let J=z;return J=await c(J,H,U,W),J=await d(J,H,U,W),J=await u(J,H,U,W),J}class w{_connection;connection(z){return this._connection=z,this}async create(z,H){let U=new C(z);H(U);let W=U.toCreateSQL();await F(this._connection).execute(W)}async drop(z){await F(this._connection).execute(`DROP TABLE IF EXISTS ${z}`)}async rename(z,H){await F(this._connection).execute(`ALTER TABLE ${z} RENAME TO ${H}`)}async hasTable(z){let H=F(this._connection);try{return await H.query(`SELECT 1 FROM ${z} LIMIT 1`),!0}catch{return!1}}}class C{table;columns=[];indices=[];constructor(z){this.table=z}id(z="id"){return this.columns.push(`${z} INTEGER PRIMARY KEY AUTOINCREMENT`),this}string(z,H=255){return this.columns.push(`${z} VARCHAR(${H})`),this}text(z){return this.columns.push(`${z} TEXT`),this}integer(z){return this.columns.push(`${z} INTEGER`),this}boolean(z){return this.columns.push(`${z} BOOLEAN DEFAULT 0`),this}datetime(z){return this.columns.push(`${z} DATETIME`),this}timestamps(){return this.columns.push("created_at DATETIME DEFAULT CURRENT_TIMESTAMP"),this.columns.push("updated_at DATETIME DEFAULT CURRENT_TIMESTAMP"),this}softDeletes(){return this.columns.push("deleted_at DATETIME"),this}json(z){return this.columns.push(`${z} TEXT`),this}foreignId(z){return this.columns.push(`${z} INTEGER`),this}index(z){let H=Array.isArray(z)?z:[z],U=`idx_${this.table}_${H.join("_")}`;return this.indices.push(`CREATE INDEX ${U} ON ${this.table} (${H.join(", ")})`),this}unique(z){let H=Array.isArray(z)?z:[z],U=`uniq_${this.table}_${H.join("_")}`;return this.indices.push(`CREATE UNIQUE INDEX ${U} ON ${this.table} (${H.join(", ")})`),this}toCreateSQL(){return`CREATE TABLE IF NOT EXISTS ${this.table} (
+  ${this.columns.join(`,
+  `)}
+)`}getIndexSQL(){return this.indices}}function _z(){return new w}export{Hz as transaction,n as table,_z as schema,a as resetDatabaseConfig,t as registerAdapter,E as raw,G as query,c as processQueryDirective,d as processModelDirective,u as processDbDirective,Zz as processDatabaseDirectives,zz as hasModel,Wz as getQueryLog,Uz as getQueryCacheStats,k as getModel,r as getDatabaseConfig,F as getAdapter,Yz as enableQueryLogging,e as defineModel,o as configureDatabase,Xz as clearQueryLog,Jz as clearQueryCache,w as SchemaBuilder,D as QueryBuilder,O as DatabaseError,C as Blueprint};

package/dist/defer.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Process @defer directives in template
+ */
+export declare function processDeferDirectives(template: string, _context: Record<string, unknown>, _filePath: string): string;