@ohos-ports/stacksjs-stx 0.2.287-beta.0

package/dist/custom-directives.js

@@ -0,0 +1,136 @@
+import { ErrorCodes, inlineError } from "./error-handling.js";
+import { getCachedRegex } from "./performance-utils.js";
+export async function processCustomDirectives(template, context, filePath, options) {
+  if (!options.customDirectives || options.customDirectives.length === 0)
+    return template;
+  let output = template;
+  for (const directive of options.customDirectives) {
+    if (!directive.name || typeof directive.handler !== "function") {
+      if (options.debug)
+        console.warn("Invalid custom directive:", directive);
+      continue;
+    }
+    if (directive.hasEndTag)
+      output = await processDirectiveWithEndTag(output, directive, context, filePath, options);
+    else
+      output = await processDirectiveWithoutEndTag(output, directive, context, filePath, options);
+  }
+  return output;
+}
+async function processDirectiveWithEndTag(template, directive, context, filePath, options) {
+  const { name, handler } = directive, startTag = `@${name}`, endTag = `@end${name}`;
+  let output = template;
+  const pattern = getCachedRegex(`${startTag}(?:\\s*\\(([^()]*(?:\\([^)]*\\)[^()]*)*)\\))?([\\s\\S]*?)${endTag}`, "g"), replacements = [];
+  let match = pattern.exec(output);
+  while (match !== null) {
+    const [fullMatch, paramString = "", content = ""] = match, startIndex = match.index || 0;
+    try {
+      const params = paramString ? parseDirectiveParams(paramString) : [], trimmedContent = content.trim(), processed = await handler(trimmedContent, params, context, filePath);
+      replacements.push({
+        original: fullMatch,
+        processed,
+        startIndex
+      });
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (options.debug)
+        console.error(`Error processing custom directive @${name}:`, error);
+      replacements.push({
+        original: fullMatch,
+        processed: inlineError("CustomDirective", `Error in @${name}${paramString ? `(${paramString})` : ""}: ${errorMessage}`, ErrorCodes.EVALUATION_ERROR),
+        startIndex
+      });
+    }
+    match = pattern.exec(output);
+  }
+  for (let i = replacements.length - 1;i >= 0; i--) {
+    const { original, processed } = replacements[i];
+    output = output.replace(original, processed);
+  }
+  return output;
+}
+async function processDirectiveWithoutEndTag(template, directive, context, filePath, options) {
+  const { name, handler } = directive;
+  let output = template;
+  const pattern = getCachedRegex(`@${name}\\s*\\(([^()]*(?:\\([^)]*\\)[^()]*)*)\\)`, "g"), replacements = [];
+  let match = pattern.exec(output);
+  while (match !== null) {
+    const [fullMatch, paramString = ""] = match, startIndex = match.index || 0;
+    try {
+      const params = parseDirectiveParams(paramString), processed = await handler("", params, context, filePath);
+      replacements.push({
+        original: fullMatch,
+        processed,
+        startIndex
+      });
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (options.debug)
+        console.error(`Error processing custom directive @${name}:`, error);
+      replacements.push({
+        original: fullMatch,
+        processed: inlineError("CustomDirective", `Error in @${name}(${paramString}): ${errorMessage}`, ErrorCodes.EVALUATION_ERROR),
+        startIndex
+      });
+    }
+    match = pattern.exec(output);
+  }
+  const barePattern = getCachedRegex(`@${name}(?!\\w)(?!\\s*\\()`, "g");
+  let bareMatch = barePattern.exec(output);
+  while (bareMatch !== null) {
+    const [fullMatch] = bareMatch, startIndex = bareMatch.index || 0;
+    try {
+      const processed = await handler("", [], context, filePath);
+      replacements.push({
+        original: fullMatch,
+        processed,
+        startIndex
+      });
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (options.debug)
+        console.error(`Error processing custom directive @${name}:`, error);
+      replacements.push({
+        original: fullMatch,
+        processed: inlineError("CustomDirective", `Error in @${name}: ${errorMessage}`, ErrorCodes.EVALUATION_ERROR),
+        startIndex
+      });
+    }
+    bareMatch = barePattern.exec(output);
+  }
+  for (let i = replacements.length - 1;i >= 0; i--) {
+    const { original, processed } = replacements[i];
+    output = output.replace(original, processed);
+  }
+  return output;
+}
+function parseDirectiveParams(paramString) {
+  if (!paramString.trim())
+    return [];
+  const params = [];
+  let currentParam = "", inQuotes = !1, quoteChar = "";
+  for (let i = 0;i < paramString.length; i++) {
+    const char = paramString[i];
+    if ((char === '"' || char === "'") && (i === 0 || paramString[i - 1] !== "\\"))
+      if (!inQuotes) {
+        inQuotes = !0;
+        quoteChar = char;
+      } else if (char === quoteChar)
+        inQuotes = !1;
+      else
+        currentParam += char;
+    else if (char === "," && !inQuotes) {
+      params.push(currentParam.trim());
+      currentParam = "";
+    } else
+      currentParam += char;
+  }
+  if (currentParam.trim())
+    params.push(currentParam.trim());
+  return params.map((param) => {
+    const trimmed = param.trim();
+    if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'"))
+      return trimmed.substring(1, trimmed.length - 1);
+    return trimmed;
+  });
+}

package/dist/database.d.ts

@@ -0,0 +1,391 @@
+/// <reference path="./stx.d.ts" />
+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;
+declare const queryLog: never[];
+/**
+ * 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
+  [key: string]: unknown
+}
+/**
+ * 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 {
+  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[] };
+  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 {
+  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 {
+  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
+import{gv as Q}from"./chunk-qc1f74ek.js";var $={default:"sqlite",connections:{},logging:!1,cacheTTL:0,maxCacheSize:1000},V={},A={},L=new Map,S=[];function i(z){$={...$,...z}}function o(){return{...$}}function r(){$={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 a(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 t(z){return G(z)}function E(z,H=[]){return{__raw:!0,sql:z,bindings:H}}function n(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 e(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 zz(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 Hz(){L.clear()}function Jz(){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 Uz(){return[...S]}function Wz(){S.length=0}function Xz(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 Yz(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 Zz(){return new w}export{zz as transaction,t as table,Zz as schema,r as resetDatabaseConfig,a as registerAdapter,E as raw,G as query,c as processQueryDirective,d as processModelDirective,u as processDbDirective,Yz as processDatabaseDirectives,e as hasModel,Uz as getQueryLog,Jz as getQueryCacheStats,k as getModel,o as getDatabaseConfig,F as getAdapter,Xz as enableQueryLogging,n as defineModel,i as configureDatabase,Wz as clearQueryLog,Hz as clearQueryCache,w as SchemaBuilder,D as QueryBuilder,O as DatabaseError,C as Blueprint};

package/dist/defer.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Defer Directive
+ *
+ * Lazy loads content based on various triggers.
+ *
+ * Usage:
+ * @defer(on: 'visible')
+ *   <HeavyComponent />
+ * @placeholder
+ *   <Skeleton />
+ * @loading
+ *   <Spinner />
+ * @error
+ *   <div>Failed to load</div>
+ * @enddefer
+ *
+ * Triggers:
+ * - 'visible' - Load when element enters viewport (IntersectionObserver)
+ * - 'idle' - Load when browser is idle (requestIdleCallback)
+ * - 'interaction' - Load on first interaction (click, focus)
+ * - 'hover' - Load on hover
+ * - 'timer(ms)' - Load after specified milliseconds
+ * - 'immediate' - Load immediately but async (default)
+ */
+/**
+ * Process @defer directives in template
+ */
+export declare function processDeferDirectives(template: string, _context: Record<string, unknown>, _filePath: string): string;