duckpond 0.3.0 → 0.4.1

package/dist/types.d.ts

@@ -1,145 +1,147 @@
-import { DuckDBConnection } from '@duckdb/node-api';
-import { Either } from 'functype/either';
-import { List } from 'functype/list';
+import { DuckDBConnection } from "@duckdb/node-api";
+import { List } from "functype/list";
+import { Either } from "functype/either";
+
+//#region src/types.d.ts
 
 /**
  * Configuration for DuckPond manager
  */
 interface DuckPondConfig {
-    r2?: {
-        accountId: string;
-        accessKeyId: string;
-        secretAccessKey: string;
-        bucket: string;
-    };
-    s3?: {
-        region: string;
-        accessKeyId: string;
-        secretAccessKey: string;
-        bucket: string;
-        endpoint?: string;
-    };
-    memoryLimit?: string;
-    threads?: number;
-    tempDir?: string;
-    dataDir?: string;
-    maxActiveUsers?: number;
-    evictionTimeout?: number;
-    cacheType?: "disk" | "memory" | "noop";
-    cacheDir?: string;
-    strategy?: "parquet" | "duckdb" | "hybrid";
+  r2?: {
+    accountId: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    bucket: string;
+  };
+  s3?: {
+    region: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    bucket: string;
+    endpoint?: string;
+  };
+  memoryLimit?: string;
+  threads?: number;
+  tempDir?: string;
+  dataDir?: string;
+  maxActiveUsers?: number;
+  evictionTimeout?: number;
+  cacheType?: "disk" | "memory" | "noop";
+  cacheDir?: string;
+  strategy?: "parquet" | "duckdb" | "hybrid";
 }
 /**
  * Represents an active user database connection
  */
 interface UserDatabase {
-    userId: string;
-    connection: DuckDBConnection;
-    lastAccess: Date;
-    attached: boolean;
-    memoryUsage?: number;
+  userId: string;
+  connection: DuckDBConnection;
+  lastAccess: Date;
+  attached: boolean;
+  memoryUsage?: number;
 }
 /**
  * Statistics about a user's database
  */
 interface UserStats {
-    userId: string;
-    attached: boolean;
-    lastAccess: Date;
-    memoryUsage: number;
-    storageUsage: number;
-    queryCount: number;
+  userId: string;
+  attached: boolean;
+  lastAccess: Date;
+  memoryUsage: number;
+  storageUsage: number;
+  queryCount: number;
 }
 /**
  * Database schema information
  */
 interface Schema {
-    tables: TableSchema[];
+  tables: TableSchema[];
 }
 interface TableSchema {
-    name: string;
-    columns: ColumnSchema[];
-    rowCount?: number;
+  name: string;
+  columns: ColumnSchema[];
+  rowCount?: number;
 }
 interface ColumnSchema {
-    name: string;
-    type: string;
-    nullable: boolean;
+  name: string;
+  type: string;
+  nullable: boolean;
 }
 /**
  * Options for creating a new user
  */
 interface CreateUserOptions {
-    template?: string;
-    initialData?: Record<string, unknown[]>;
-    metadata?: Record<string, unknown>;
+  template?: string;
+  initialData?: Record<string, unknown[]>;
+  metadata?: Record<string, unknown>;
 }
 /**
  * Storage usage statistics
  */
 interface StorageStats {
-    totalSize: number;
-    fileCount: number;
-    lastModified: Date;
-    files?: FileInfo[];
+  totalSize: number;
+  fileCount: number;
+  lastModified: Date;
+  files?: FileInfo[];
 }
 interface FileInfo {
-    path: string;
-    size: number;
-    modified: Date;
+  path: string;
+  size: number;
+  modified: Date;
 }
 /**
  * Query result with metadata
  */
 interface QueryResult<T = unknown> {
-    rows: T[];
-    rowCount: number;
-    executionTime: number;
-    columns: string[];
+  rows: T[];
+  rowCount: number;
+  executionTime: number;
+  columns: string[];
 }
 /**
  * Metrics for monitoring
  */
 interface DuckPondMetrics {
-    activeUsers: number;
-    totalQueries: number;
-    avgQueryTime: number;
-    cacheHitRate: number;
-    memoryUsage: number;
-    storageUsage: number;
+  activeUsers: number;
+  totalQueries: number;
+  avgQueryTime: number;
+  cacheHitRate: number;
+  memoryUsage: number;
+  storageUsage: number;
 }
 /**
  * Events emitted by DuckPond
  */
 type DuckPondEvent = {
-    type: "user:attached";
-    userId: string;
-    timestamp: Date;
+  type: "user:attached";
+  userId: string;
+  timestamp: Date;
 } | {
-    type: "user:detached";
-    userId: string;
-    reason: "eviction" | "manual";
-    timestamp: Date;
+  type: "user:detached";
+  userId: string;
+  reason: "eviction" | "manual";
+  timestamp: Date;
 } | {
-    type: "query:executed";
-    userId: string;
-    duration: number;
-    timestamp: Date;
+  type: "query:executed";
+  userId: string;
+  duration: number;
+  timestamp: Date;
 } | {
-    type: "query:failed";
-    userId: string;
-    error: string;
-    timestamp: Date;
+  type: "query:failed";
+  userId: string;
+  error: string;
+  timestamp: Date;
 } | {
-    type: "cache:hit";
-    userId: string;
+  type: "cache:hit";
+  userId: string;
 } | {
-    type: "cache:miss";
-    userId: string;
+  type: "cache:miss";
+  userId: string;
 } | {
-    type: "error";
-    error: Error;
-    timestamp: Date;
+  type: "error";
+  error: Error;
+  timestamp: Date;
 };
 /**
  * Type-safe result types using functype Either
@@ -150,45 +152,46 @@ type AsyncDuckPondResult<T> = Promise<Either<DuckPondError, T>>;
  * Error types
  */
 interface DuckPondError {
-    code: ErrorCode;
-    message: string;
-    cause?: Error;
-    context?: Record<string, unknown>;
+  code: ErrorCode;
+  message: string;
+  cause?: Error;
+  context?: Record<string, unknown>;
 }
 declare enum ErrorCode {
-    CONNECTION_FAILED = "CONNECTION_FAILED",
-    CONNECTION_TIMEOUT = "CONNECTION_TIMEOUT",
-    R2_CONNECTION_ERROR = "R2_CONNECTION_ERROR",
-    S3_CONNECTION_ERROR = "S3_CONNECTION_ERROR",
-    USER_NOT_FOUND = "USER_NOT_FOUND",
-    USER_ALREADY_EXISTS = "USER_ALREADY_EXISTS",
-    USER_NOT_ATTACHED = "USER_NOT_ATTACHED",
-    QUERY_EXECUTION_ERROR = "QUERY_EXECUTION_ERROR",
-    QUERY_TIMEOUT = "QUERY_TIMEOUT",
-    INVALID_SQL = "INVALID_SQL",
-    MEMORY_LIMIT_EXCEEDED = "MEMORY_LIMIT_EXCEEDED",
-    STORAGE_ERROR = "STORAGE_ERROR",
-    STORAGE_QUOTA_EXCEEDED = "STORAGE_QUOTA_EXCEEDED",
-    INVALID_CONFIG = "INVALID_CONFIG",
-    NOT_INITIALIZED = "NOT_INITIALIZED",
-    UNKNOWN_ERROR = "UNKNOWN_ERROR"
+  CONNECTION_FAILED = "CONNECTION_FAILED",
+  CONNECTION_TIMEOUT = "CONNECTION_TIMEOUT",
+  R2_CONNECTION_ERROR = "R2_CONNECTION_ERROR",
+  S3_CONNECTION_ERROR = "S3_CONNECTION_ERROR",
+  USER_NOT_FOUND = "USER_NOT_FOUND",
+  USER_ALREADY_EXISTS = "USER_ALREADY_EXISTS",
+  USER_NOT_ATTACHED = "USER_NOT_ATTACHED",
+  QUERY_EXECUTION_ERROR = "QUERY_EXECUTION_ERROR",
+  QUERY_TIMEOUT = "QUERY_TIMEOUT",
+  INVALID_SQL = "INVALID_SQL",
+  MEMORY_LIMIT_EXCEEDED = "MEMORY_LIMIT_EXCEEDED",
+  STORAGE_ERROR = "STORAGE_ERROR",
+  STORAGE_QUOTA_EXCEEDED = "STORAGE_QUOTA_EXCEEDED",
+  INVALID_CONFIG = "INVALID_CONFIG",
+  NOT_INITIALIZED = "NOT_INITIALIZED",
+  UNKNOWN_ERROR = "UNKNOWN_ERROR",
 }
 /**
  * Configuration with defaults applied
  */
 type ResolvedConfig = Required<Omit<DuckPondConfig, "r2" | "s3" | "dataDir"> & {
-    r2: DuckPondConfig["r2"];
-    s3: DuckPondConfig["s3"];
-    dataDir: DuckPondConfig["dataDir"];
+  r2: DuckPondConfig["r2"];
+  s3: DuckPondConfig["s3"];
+  dataDir: DuckPondConfig["dataDir"];
 }>;
 /**
  * Result of listUsers operation
  */
 interface ListUsersResult {
-    users: List<string>;
-    count: number;
-    maxActiveUsers: number;
-    utilizationPercent: number;
+  users: List<string>;
+  count: number;
+  maxActiveUsers: number;
+  utilizationPercent: number;
 }
-
-export { type AsyncDuckPondResult, type ColumnSchema, type CreateUserOptions, type DuckPondConfig, type DuckPondError, type DuckPondEvent, type DuckPondMetrics, type DuckPondResult, ErrorCode, type FileInfo, type ListUsersResult, type QueryResult, type ResolvedConfig, type Schema, type StorageStats, type TableSchema, type UserDatabase, type UserStats };
+//#endregion
+export { AsyncDuckPondResult, ColumnSchema, CreateUserOptions, DuckPondConfig, DuckPondError, DuckPondEvent, DuckPondMetrics, DuckPondResult, ErrorCode, FileInfo, ListUsersResult, QueryResult, ResolvedConfig, Schema, StorageStats, TableSchema, UserDatabase, UserStats };
+//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkLG2XWWAPjs = require('./chunk-LG2XWWAP.js');require('./chunk-5XGN7UAV.js');exports.ErrorCode = _chunkLG2XWWAPjs.a;
+let e=function(e){return e.CONNECTION_FAILED=`CONNECTION_FAILED`,e.CONNECTION_TIMEOUT=`CONNECTION_TIMEOUT`,e.R2_CONNECTION_ERROR=`R2_CONNECTION_ERROR`,e.S3_CONNECTION_ERROR=`S3_CONNECTION_ERROR`,e.USER_NOT_FOUND=`USER_NOT_FOUND`,e.USER_ALREADY_EXISTS=`USER_ALREADY_EXISTS`,e.USER_NOT_ATTACHED=`USER_NOT_ATTACHED`,e.QUERY_EXECUTION_ERROR=`QUERY_EXECUTION_ERROR`,e.QUERY_TIMEOUT=`QUERY_TIMEOUT`,e.INVALID_SQL=`INVALID_SQL`,e.MEMORY_LIMIT_EXCEEDED=`MEMORY_LIMIT_EXCEEDED`,e.STORAGE_ERROR=`STORAGE_ERROR`,e.STORAGE_QUOTA_EXCEEDED=`STORAGE_QUOTA_EXCEEDED`,e.INVALID_CONFIG=`INVALID_CONFIG`,e.NOT_INITIALIZED=`NOT_INITIALIZED`,e.UNKNOWN_ERROR=`UNKNOWN_ERROR`,e}({});export{e as ErrorCode};
 //# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/jordanburke/IdeaProjects/duckpond/dist/types.js"],"names":[],"mappings":"AAAA,+HAAkC,+BAA4B,uCAAuB","file":"/Users/jordanburke/IdeaProjects/duckpond/dist/types.js"}
+{"version":3,"file":"types.js","names":[],"sources":["../src/types.ts"],"sourcesContent":["import type { DuckDBConnection } from \"@duckdb/node-api\"\nimport type { Either } from \"functype/either\"\nimport type { List } from \"functype/list\"\nimport type { Option } from \"functype/option\"\n\n/**\n * Configuration for DuckPond manager\n */\nexport interface DuckPondConfig {\n  // R2 Configuration (Cloudflare)\n  r2?: {\n    accountId: string\n    accessKeyId: string\n    secretAccessKey: string\n    bucket: string\n  }\n\n  // S3 Configuration (AWS)\n  s3?: {\n    region: string\n    accessKeyId: string\n    secretAccessKey: string\n    bucket: string\n    endpoint?: string // For S3-compatible services\n  }\n\n  // DuckDB Settings\n  memoryLimit?: string // Default: '4GB'\n  threads?: number // Default: 4\n  tempDir?: string // Default: '/tmp/duckpond'\n\n  // Local Storage\n  dataDir?: string // Directory for persistent database files (enables local storage when set)\n\n  // Cache Settings\n  maxActiveUsers?: number // Default: 10\n  evictionTimeout?: number // Default: 300000 (5 min in ms)\n  cacheType?: \"disk\" | \"memory\" | \"noop\" // Default: 'disk'\n  cacheDir?: string // Default: '/tmp/duckpond-cache'\n\n  // Storage Strategy\n  strategy?: \"parquet\" | \"duckdb\" | \"hybrid\" // Default: 'parquet'\n}\n\n/**\n * Represents an active user database connection\n */\nexport interface UserDatabase {\n  userId: string\n  connection: DuckDBConnection\n  lastAccess: Date\n  attached: boolean\n  memoryUsage?: number\n}\n\n/**\n * Statistics about a user's database\n */\nexport interface UserStats {\n  userId: string\n  attached: boolean\n  lastAccess: Date\n  memoryUsage: number\n  storageUsage: number\n  queryCount: number\n}\n\n/**\n * Database schema information\n */\nexport interface Schema {\n  tables: TableSchema[]\n}\n\nexport interface TableSchema {\n  name: string\n  columns: ColumnSchema[]\n  rowCount?: number\n}\n\nexport interface ColumnSchema {\n  name: string\n  type: string\n  nullable: boolean\n}\n\n/**\n * Options for creating a new user\n */\nexport interface CreateUserOptions {\n  template?: string\n  initialData?: Record<string, unknown[]>\n  metadata?: Record<string, unknown>\n}\n\n/**\n * Storage usage statistics\n */\nexport interface StorageStats {\n  totalSize: number\n  fileCount: number\n  lastModified: Date\n  files?: FileInfo[]\n}\n\nexport interface FileInfo {\n  path: string\n  size: number\n  modified: Date\n}\n\n/**\n * Query result with metadata\n */\nexport interface QueryResult<T = unknown> {\n  rows: T[]\n  rowCount: number\n  executionTime: number\n  columns: string[]\n}\n\n/**\n * Metrics for monitoring\n */\nexport interface DuckPondMetrics {\n  activeUsers: number\n  totalQueries: number\n  avgQueryTime: number\n  cacheHitRate: number\n  memoryUsage: number\n  storageUsage: number\n}\n\n/**\n * Events emitted by DuckPond\n */\nexport type DuckPondEvent =\n  | { type: \"user:attached\"; userId: string; timestamp: Date }\n  | { type: \"user:detached\"; userId: string; reason: \"eviction\" | \"manual\"; timestamp: Date }\n  | { type: \"query:executed\"; userId: string; duration: number; timestamp: Date }\n  | { type: \"query:failed\"; userId: string; error: string; timestamp: Date }\n  | { type: \"cache:hit\"; userId: string }\n  | { type: \"cache:miss\"; userId: string }\n  | { type: \"error\"; error: Error; timestamp: Date }\n\n/**\n * Type-safe result types using functype Either\n */\nexport type DuckPondResult<T> = Either<DuckPondError, T>\nexport type AsyncDuckPondResult<T> = Promise<Either<DuckPondError, T>>\n\n/**\n * Error types\n */\nexport interface DuckPondError {\n  code: ErrorCode\n  message: string\n  cause?: Error\n  context?: Record<string, unknown>\n}\n\nexport enum ErrorCode {\n  // Connection errors\n  CONNECTION_FAILED = \"CONNECTION_FAILED\",\n  CONNECTION_TIMEOUT = \"CONNECTION_TIMEOUT\",\n  R2_CONNECTION_ERROR = \"R2_CONNECTION_ERROR\",\n  S3_CONNECTION_ERROR = \"S3_CONNECTION_ERROR\",\n\n  // User errors\n  USER_NOT_FOUND = \"USER_NOT_FOUND\",\n  USER_ALREADY_EXISTS = \"USER_ALREADY_EXISTS\",\n  USER_NOT_ATTACHED = \"USER_NOT_ATTACHED\",\n\n  // Query errors\n  QUERY_EXECUTION_ERROR = \"QUERY_EXECUTION_ERROR\",\n  QUERY_TIMEOUT = \"QUERY_TIMEOUT\",\n  INVALID_SQL = \"INVALID_SQL\",\n\n  // Resource errors\n  MEMORY_LIMIT_EXCEEDED = \"MEMORY_LIMIT_EXCEEDED\",\n  STORAGE_ERROR = \"STORAGE_ERROR\",\n  STORAGE_QUOTA_EXCEEDED = \"STORAGE_QUOTA_EXCEEDED\",\n\n  // Configuration errors\n  INVALID_CONFIG = \"INVALID_CONFIG\",\n  NOT_INITIALIZED = \"NOT_INITIALIZED\",\n\n  // Unknown\n  UNKNOWN_ERROR = \"UNKNOWN_ERROR\",\n}\n\n/**\n * Configuration with defaults applied\n */\nexport type ResolvedConfig = Required<\n  Omit<DuckPondConfig, \"r2\" | \"s3\" | \"dataDir\"> & {\n    r2: DuckPondConfig[\"r2\"]\n    s3: DuckPondConfig[\"s3\"]\n    dataDir: DuckPondConfig[\"dataDir\"]\n  }\n>\n\n/**\n * Result of listUsers operation\n */\nexport interface ListUsersResult {\n  users: List<string> // List of cached user IDs (functype immutable list)\n  count: number // Number of cached users\n  maxActiveUsers: number // Maximum cache capacity\n  utilizationPercent: number // Cache utilization (0-100)\n}\n"],"mappings":"AAiKA,IAAY,EAAA,SAAA,EAAL,OAEL,GAAA,kBAAA,oBACA,EAAA,mBAAA,qBACA,EAAA,oBAAA,sBACA,EAAA,oBAAA,sBAGA,EAAA,eAAA,iBACA,EAAA,oBAAA,sBACA,EAAA,kBAAA,oBAGA,EAAA,sBAAA,wBACA,EAAA,cAAA,gBACA,EAAA,YAAA,cAGA,EAAA,sBAAA,wBACA,EAAA,cAAA,gBACA,EAAA,uBAAA,yBAGA,EAAA,eAAA,iBACA,EAAA,gBAAA,kBAGA,EAAA,cAAA"}

package/dist/utils/errors.d.ts

@@ -1,8 +1,7 @@
-import { Either } from 'functype';
-import { ErrorCode, DuckPondError } from '../types.js';
-import '@duckdb/node-api';
-import 'functype/either';
-import 'functype/list';
+import { DuckPondError, ErrorCode } from "../types.js";
+import { Either } from "functype";
+
+//#region src/utils/errors.d.ts
 
 /**
  * Create a DuckPondError as a Left Either
@@ -20,22 +19,23 @@ declare function toDuckPondError(error: unknown, defaultCode?: ErrorCode): DuckP
  * Error factory functions for common errors
  */
 declare const Errors: {
-    connectionFailed: (message: string, cause?: Error) => Either<DuckPondError, never>;
-    r2ConnectionError: (message: string, cause?: Error) => Either<DuckPondError, never>;
-    s3ConnectionError: (message: string, cause?: Error) => Either<DuckPondError, never>;
-    userNotFound: (userId: string) => Either<DuckPondError, never>;
-    userAlreadyExists: (userId: string) => Either<DuckPondError, never>;
-    userNotAttached: (userId: string) => Either<DuckPondError, never>;
-    queryExecutionError: (message: string, sql?: string, cause?: Error) => Either<DuckPondError, never>;
-    queryTimeout: (timeoutMs: number) => Either<DuckPondError, never>;
-    memoryLimitExceeded: (limit: string) => Either<DuckPondError, never>;
-    storageError: (message: string, cause?: Error) => Either<DuckPondError, never>;
-    invalidConfig: (message: string) => Either<DuckPondError, never>;
-    notInitialized: () => Either<DuckPondError, never>;
+  connectionFailed: (message: string, cause?: Error) => Either<DuckPondError, never>;
+  r2ConnectionError: (message: string, cause?: Error) => Either<DuckPondError, never>;
+  s3ConnectionError: (message: string, cause?: Error) => Either<DuckPondError, never>;
+  userNotFound: (userId: string) => Either<DuckPondError, never>;
+  userAlreadyExists: (userId: string) => Either<DuckPondError, never>;
+  userNotAttached: (userId: string) => Either<DuckPondError, never>;
+  queryExecutionError: (message: string, sql?: string, cause?: Error) => Either<DuckPondError, never>;
+  queryTimeout: (timeoutMs: number) => Either<DuckPondError, never>;
+  memoryLimitExceeded: (limit: string) => Either<DuckPondError, never>;
+  storageError: (message: string, cause?: Error) => Either<DuckPondError, never>;
+  invalidConfig: (message: string) => Either<DuckPondError, never>;
+  notInitialized: () => Either<DuckPondError, never>;
 };
 /**
  * Format an error for logging
  */
 declare function formatError(error: DuckPondError): string;
-
+//#endregion
 export { Errors, createError, formatError, success, toDuckPondError };
+//# sourceMappingURL=errors.d.ts.map

package/dist/utils/errors.js

@@ -1,2 +1,3 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkMZTKR3LRjs = require('../chunk-MZTKR3LR.js');require('../chunk-LG2XWWAP.js');require('../chunk-5XGN7UAV.js');exports.Errors = _chunkMZTKR3LRjs.d; exports.createError = _chunkMZTKR3LRjs.a; exports.formatError = _chunkMZTKR3LRjs.e; exports.success = _chunkMZTKR3LRjs.b; exports.toDuckPondError = _chunkMZTKR3LRjs.c;
+import{ErrorCode as e}from"../types.js";import{Left as t,Right as n}from"functype";function r(e,n,r,i){return t({code:e,message:n,cause:r,context:i})}function i(e){return n(e)}function a(t,n=e.UNKNOWN_ERROR){return t instanceof Error?{code:n,message:t.message,cause:t}:{code:n,message:String(t)}}const o={connectionFailed:(t,n)=>r(e.CONNECTION_FAILED,t,n),r2ConnectionError:(t,n)=>r(e.R2_CONNECTION_ERROR,t,n),s3ConnectionError:(t,n)=>r(e.S3_CONNECTION_ERROR,t,n),userNotFound:t=>r(e.USER_NOT_FOUND,`User not found: ${t}`,void 0,{userId:t}),userAlreadyExists:t=>r(e.USER_ALREADY_EXISTS,`User already exists: ${t}`,void 0,{userId:t}),userNotAttached:t=>r(e.USER_NOT_ATTACHED,`User not attached: ${t}`,void 0,{userId:t}),queryExecutionError:(t,n,i)=>r(e.QUERY_EXECUTION_ERROR,t,i,{sql:n}),queryTimeout:t=>r(e.QUERY_TIMEOUT,`Query timeout after ${t}ms`,void 0,{timeoutMs:t}),memoryLimitExceeded:t=>r(e.MEMORY_LIMIT_EXCEEDED,`Memory limit exceeded: ${t}`,void 0,{limit:t}),storageError:(t,n)=>r(e.STORAGE_ERROR,t,n),invalidConfig:t=>r(e.INVALID_CONFIG,t),notInitialized:()=>r(e.NOT_INITIALIZED,`DuckPond not initialized. Call init() first.`)};function s(e){let t=[`[${e.code}] ${e.message}`];return e.cause&&t.push(`  Caused by: ${e.cause.message}`),e.context&&t.push(`  Context: ${JSON.stringify(e.context)}`),t.join(`
+`)}export{o as Errors,r as createError,s as formatError,i as success,a as toDuckPondError};
 //# sourceMappingURL=errors.js.map

package/dist/utils/errors.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/jordanburke/IdeaProjects/duckpond/dist/utils/errors.js"],"names":[],"mappings":"AAAA,gIAA2C,gCAA6B,gCAA6B,4MAAwF","file":"/Users/jordanburke/IdeaProjects/duckpond/dist/utils/errors.js"}
+{"version":3,"file":"errors.js","names":[],"sources":["../../src/utils/errors.ts"],"sourcesContent":["import { type Either, Left, Right } from \"functype\"\n\nimport { DuckPondError, ErrorCode } from \"../types\"\n\n/**\n * Create a DuckPondError as a Left Either\n */\nexport function createError(\n  code: ErrorCode,\n  message: string,\n  cause?: Error,\n  context?: Record<string, unknown>,\n): Either<DuckPondError, never> {\n  return Left({\n    code,\n    message,\n    cause,\n    context,\n  })\n}\n\n/**\n * Wrap a value in a Right Either\n */\nexport function success<T = void>(value?: T): Either<DuckPondError, T extends void ? void : T> {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return Right(value) as any\n}\n\n/**\n * Convert an unknown error to a DuckPondError\n */\nexport function toDuckPondError(error: unknown, defaultCode: ErrorCode = ErrorCode.UNKNOWN_ERROR): DuckPondError {\n  if (error instanceof Error) {\n    return {\n      code: defaultCode,\n      message: error.message,\n      cause: error,\n    }\n  }\n\n  return {\n    code: defaultCode,\n    message: String(error),\n  }\n}\n\n/**\n * Error factory functions for common errors\n */\nexport const Errors = {\n  connectionFailed: (message: string, cause?: Error) => createError(ErrorCode.CONNECTION_FAILED, message, cause),\n\n  r2ConnectionError: (message: string, cause?: Error) => createError(ErrorCode.R2_CONNECTION_ERROR, message, cause),\n\n  s3ConnectionError: (message: string, cause?: Error) => createError(ErrorCode.S3_CONNECTION_ERROR, message, cause),\n\n  userNotFound: (userId: string) =>\n    createError(ErrorCode.USER_NOT_FOUND, `User not found: ${userId}`, undefined, { userId }),\n\n  userAlreadyExists: (userId: string) =>\n    createError(ErrorCode.USER_ALREADY_EXISTS, `User already exists: ${userId}`, undefined, {\n      userId,\n    }),\n\n  userNotAttached: (userId: string) =>\n    createError(ErrorCode.USER_NOT_ATTACHED, `User not attached: ${userId}`, undefined, {\n      userId,\n    }),\n\n  queryExecutionError: (message: string, sql?: string, cause?: Error) =>\n    createError(ErrorCode.QUERY_EXECUTION_ERROR, message, cause, { sql }),\n\n  queryTimeout: (timeoutMs: number) =>\n    createError(ErrorCode.QUERY_TIMEOUT, `Query timeout after ${timeoutMs}ms`, undefined, {\n      timeoutMs,\n    }),\n\n  memoryLimitExceeded: (limit: string) =>\n    createError(ErrorCode.MEMORY_LIMIT_EXCEEDED, `Memory limit exceeded: ${limit}`, undefined, {\n      limit,\n    }),\n\n  storageError: (message: string, cause?: Error) => createError(ErrorCode.STORAGE_ERROR, message, cause),\n\n  invalidConfig: (message: string) => createError(ErrorCode.INVALID_CONFIG, message),\n\n  notInitialized: () => createError(ErrorCode.NOT_INITIALIZED, \"DuckPond not initialized. Call init() first.\"),\n}\n\n/**\n * Format an error for logging\n */\nexport function formatError(error: DuckPondError): string {\n  const parts = [`[${error.code}] ${error.message}`]\n\n  if (error.cause) {\n    parts.push(`  Caused by: ${error.cause.message}`)\n  }\n\n  if (error.context) {\n    parts.push(`  Context: ${JSON.stringify(error.context)}`)\n  }\n\n  return parts.join(\"\\n\")\n}\n"],"mappings":"mFAOA,SAAgB,EACd,EACA,EACA,EACA,EAC8B,CAC9B,OAAO,EAAK,CACV,OACA,UACA,QACA,UACD,CAAC,CAMJ,SAAgB,EAAkB,EAA6D,CAE7F,OAAO,EAAM,EAAM,CAMrB,SAAgB,EAAgB,EAAgB,EAAyB,EAAU,cAA8B,CAS/G,OARI,aAAiB,MACZ,CACL,KAAM,EACN,QAAS,EAAM,QACf,MAAO,EACR,CAGI,CACL,KAAM,EACN,QAAS,OAAO,EAAM,CACvB,CAMH,MAAa,EAAS,CACpB,kBAAmB,EAAiB,IAAkB,EAAY,EAAU,kBAAmB,EAAS,EAAM,CAE9G,mBAAoB,EAAiB,IAAkB,EAAY,EAAU,oBAAqB,EAAS,EAAM,CAEjH,mBAAoB,EAAiB,IAAkB,EAAY,EAAU,oBAAqB,EAAS,EAAM,CAEjH,aAAe,GACb,EAAY,EAAU,eAAgB,mBAAmB,IAAU,IAAA,GAAW,CAAE,SAAQ,CAAC,CAE3F,kBAAoB,GAClB,EAAY,EAAU,oBAAqB,wBAAwB,IAAU,IAAA,GAAW,CACtF,SACD,CAAC,CAEJ,gBAAkB,GAChB,EAAY,EAAU,kBAAmB,sBAAsB,IAAU,IAAA,GAAW,CAClF,SACD,CAAC,CAEJ,qBAAsB,EAAiB,EAAc,IACnD,EAAY,EAAU,sBAAuB,EAAS,EAAO,CAAE,MAAK,CAAC,CAEvE,aAAe,GACb,EAAY,EAAU,cAAe,uBAAuB,EAAU,IAAK,IAAA,GAAW,CACpF,YACD,CAAC,CAEJ,oBAAsB,GACpB,EAAY,EAAU,sBAAuB,0BAA0B,IAAS,IAAA,GAAW,CACzF,QACD,CAAC,CAEJ,cAAe,EAAiB,IAAkB,EAAY,EAAU,cAAe,EAAS,EAAM,CAEtG,cAAgB,GAAoB,EAAY,EAAU,eAAgB,EAAQ,CAElF,mBAAsB,EAAY,EAAU,gBAAiB,+CAA+C,CAC7G,CAKD,SAAgB,EAAY,EAA8B,CACxD,IAAM,EAAQ,CAAC,IAAI,EAAM,KAAK,IAAI,EAAM,UAAU,CAUlD,OARI,EAAM,OACR,EAAM,KAAK,gBAAgB,EAAM,MAAM,UAAU,CAG/C,EAAM,SACR,EAAM,KAAK,cAAc,KAAK,UAAU,EAAM,QAAQ,GAAG,CAGpD,EAAM,KAAK;EAAK"}

package/dist/utils/logger.d.ts

@@ -1,4 +1,6 @@
-import debug from 'debug';
+import debug from "debug";
+
+//#region src/utils/logger.d.ts
 
 /**
  * Create a namespaced logger for DuckPond
@@ -14,12 +16,13 @@ declare function createLogger(namespace: string): debug.Debugger;
  * Pre-configured loggers for different modules
  */
 declare const loggers: {
-    main: debug.Debugger;
-    cache: debug.Debugger;
-    connection: debug.Debugger;
-    query: debug.Debugger;
-    storage: debug.Debugger;
-    metrics: debug.Debugger;
+  main: debug.Debugger;
+  cache: debug.Debugger;
+  connection: debug.Debugger;
+  query: debug.Debugger;
+  storage: debug.Debugger;
+  metrics: debug.Debugger;
 };
-
+//#endregion
 export { createLogger, loggers };
+//# sourceMappingURL=logger.d.ts.map

package/dist/utils/logger.js

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkQ6UFPTQCjs = require('../chunk-Q6UFPTQC.js');require('../chunk-5XGN7UAV.js');exports.createLogger = _chunkQ6UFPTQCjs.a; exports.loggers = _chunkQ6UFPTQCjs.b;
+import e from"debug";function t(t){return e(`duckpond:${t}`)}const n={main:t(`main`),cache:t(`cache`),connection:t(`connection`),query:t(`query`),storage:t(`storage`),metrics:t(`metrics`)};export{t as createLogger,n as loggers};
 //# sourceMappingURL=logger.js.map

package/dist/utils/logger.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/jordanburke/IdeaProjects/duckpond/dist/utils/logger.js"],"names":[],"mappings":"AAAA,gIAAqC,gCAA6B,gFAAuC","file":"/Users/jordanburke/IdeaProjects/duckpond/dist/utils/logger.js"}
+{"version":3,"file":"logger.js","names":[],"sources":["../../src/utils/logger.ts"],"sourcesContent":["import debug from \"debug\"\n\n/**\n * Create a namespaced logger for DuckPond\n *\n * Usage:\n *   const log = createLogger('DuckPond')\n *   log('Initializing...')\n *\n * Enable with: DEBUG=duckpond:* node app.js\n */\nexport function createLogger(namespace: string): debug.Debugger {\n  return debug(`duckpond:${namespace}`)\n}\n\n/**\n * Pre-configured loggers for different modules\n */\nexport const loggers = {\n  main: createLogger(\"main\"),\n  cache: createLogger(\"cache\"),\n  connection: createLogger(\"connection\"),\n  query: createLogger(\"query\"),\n  storage: createLogger(\"storage\"),\n  metrics: createLogger(\"metrics\"),\n}\n"],"mappings":"qBAWA,SAAgB,EAAa,EAAmC,CAC9D,OAAO,EAAM,YAAY,IAAY,CAMvC,MAAa,EAAU,CACrB,KAAM,EAAa,OAAO,CAC1B,MAAO,EAAa,QAAQ,CAC5B,WAAY,EAAa,aAAa,CACtC,MAAO,EAAa,QAAQ,CAC5B,QAAS,EAAa,UAAU,CAChC,QAAS,EAAa,UAAU,CACjC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "duckpond",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "Multi-tenant DuckDB manager with R2/S3 storage and functional programming patterns",
   "keywords": [
     "duckdb",
@@ -20,61 +20,48 @@
     "type": "git",
     "url": "https://github.com/jordanburke/duckpond"
   },
+  "type": "module",
+  "scripts": {
+    "validate": "ts-builds validate",
+    "format": "ts-builds format",
+    "format:check": "ts-builds format:check",
+    "lint": "ts-builds lint",
+    "lint:check": "ts-builds lint:check",
+    "typecheck": "ts-builds typecheck",
+    "test": "ts-builds test",
+    "test:watch": "ts-builds test:watch",
+    "test:coverage": "ts-builds test:coverage",
+    "build": "ts-builds build",
+    "dev": "ts-builds dev",
+    "prepublishOnly": "pnpm validate"
+  },
+  "dependencies": {
+    "@duckdb/node-api": "1.4.4-r.1",
+    "@duckdb/node-bindings": "1.4.4-r.1",
+    "debug": "^4.4.3",
+    "functype": "^0.46.2",
+    "lru-cache": "^11.2.6"
+  },
   "devDependencies": {
-    "@eslint/eslintrc": "^3.3.3",
-    "@eslint/js": "^9.39.2",
-    "@types/node": "^22.19.3",
-    "@typescript-eslint/eslint-plugin": "^8.51.0",
-    "@typescript-eslint/parser": "^8.51.0",
-    "@vitest/coverage-v8": "4.0.16",
-    "@vitest/ui": "^4.0.16",
-    "cross-env": "^10.1.0",
-    "eslint": "^9.39.2",
-    "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-prettier": "^5.5.4",
-    "eslint-plugin-simple-import-sort": "^12.1.1",
-    "globals": "^16.5.0",
-    "prettier": "^3.7.4",
-    "rimraf": "^6.1.2",
-    "ts-node": "^10.9.2",
-    "tsup": "^8.5.1",
-    "typescript": "^5.9.3",
-    "vitest": "^4.0.16"
+    "@types/node": "~24.10.13",
+    "ts-builds": "^2.4.0",
+    "tsdown": "^0.18.4",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
   },
   "main": "./dist/index.js",
-  "module": "./dist/index.mjs",
+  "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "require": "./dist/index.js",
-      "import": "./dist/index.mjs"
+      "import": "./dist/index.js"
     }
   },
   "files": [
     "lib",
     "dist"
   ],
-  "dependencies": {
-    "@duckdb/node-api": "1.4.3-r.2",
-    "@duckdb/node-bindings": "1.4.3-r.2",
-    "debug": "^4.4.3",
-    "functype": "^0.41.3"
-  },
-  "scripts": {
-    "validate": "pnpm format && pnpm lint && pnpm test && pnpm build",
-    "format": "prettier --write .",
-    "format:check": "prettier --check .",
-    "lint": "eslint ./src --fix",
-    "lint:check": "eslint ./src",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
-    "test:ui": "vitest --ui",
-    "build": "rimraf dist && cross-env NODE_ENV=production tsup",
-    "build:watch": "tsup --watch",
-    "dev": "tsup --watch",
-    "ts-types": "tsc"
-  }
-}
+  "prettier": "ts-builds/prettier",
+  "packageManager": "pnpm@10.29.3+sha512.498e1fb4cca5aa06c1dcf2611e6fafc50972ffe7189998c409e90de74566444298ffe43e6cd2acdc775ba1aa7cc5e092a8b7054c811ba8c5770f84693d33d2dc"
+}

package/dist/DuckPond.d.mts

@@ -1,83 +0,0 @@
-import { DuckDBConnection } from '@duckdb/node-api';
-import { DuckPondConfig, AsyncDuckPondResult, UserStats, ListUsersResult } from './types.mjs';
-import 'functype/either';
-import 'functype/list';
-
-declare class DuckPond {
-    private instance;
-    private cache;
-    private config;
-    private evictionTimer;
-    private initialized;
-    constructor(config: DuckPondConfig);
-    /**
-     * Initialize DuckPond
-     * Must be called before any other operations
-     */
-    init(): AsyncDuckPondResult<void>;
-    /**
-     * Ensure the data directory exists
-     */
-    private ensureDataDir;
-    /**
-     * Get the database file path for a user
-     */
-    private getUserDbPath;
-    /**
-     * Configure R2/S3 access and DuckDB extensions
-     */
-    private setupCloudStorage;
-    /**
-     * Get a connection for a user
-     * Loads from cache or creates new database
-     */
-    getUserConnection(userId: string): AsyncDuckPondResult<DuckDBConnection>;
-    /**
-     * Create a local file-based database connection for a user
-     */
-    private createLocalUserConnection;
-    /**
-     * Attach a user's database based on storage strategy
-     */
-    private attachUserDatabase;
-    /**
-     * Execute a SQL query for a user
-     * Returns Either<Error, results>
-     */
-    query<T = unknown>(userId: string, sql: string): AsyncDuckPondResult<T[]>;
-    /**
-     * Execute SQL without returning results (DDL, DML)
-     */
-    execute(userId: string, sql: string): AsyncDuckPondResult<void>;
-    /**
-     * Detach a user's database and free resources
-     */
-    detachUser(userId: string): AsyncDuckPondResult<void>;
-    /**
-     * Evict the least recently used user
-     */
-    private evictLRU;
-    /**
-     * Start background timer to evict idle users
-     */
-    private startEvictionTimer;
-    /**
-     * Check if a user is currently attached
-     */
-    isAttached(userId: string): boolean;
-    /**
-     * Get statistics about a user's database
-     */
-    getUserStats(userId: string): AsyncDuckPondResult<UserStats>;
-    /**
-     * Get list of all currently cached users
-     * Returns a List of user IDs and cache statistics
-     */
-    listUsers(): ListUsersResult;
-    /**
-     * Close DuckPond and cleanup all resources
-     */
-    close(): AsyncDuckPondResult<void>;
-}
-
-export { DuckPond };

package/dist/DuckPond.mjs

@@ -1,2 +0,0 @@
-import{a}from"./chunk-BA7KCST7.mjs";import"./chunk-24M54WUC.mjs";import"./chunk-PCQEPXO3.mjs";import"./chunk-GXQJHTJW.mjs";import"./chunk-SZJXSB7U.mjs";import"./chunk-V57JCP3U.mjs";export{a as DuckPond};
-//# sourceMappingURL=DuckPond.mjs.map

package/dist/DuckPond.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}