[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8,"_9":10},"actionData","errors","root",{"_378":379,"_380":381},"routes/_app.x.$handle.$name",{"_98":97,"_31":44,"_106":88,"_26":107,"_13":14,"_108":-5,"_11":109,"_110":111,"_112":113,"_114":115,"_116":117,"_20":-5,"_118":-5,"_119":-5,"_120":24,"_121":122,"_123":48,"_124":-5,"_125":-5,"_126":127},"routes/_app.x.$handle.$name.branch.$branch.version.$version.diff",{"_11":12,"_13":14,"_15":16,"_17":-5,"_18":-5},"project",{"_42":43,"_31":44,"_37":45,"_46":-5,"_47":48,"_49":50,"_51":50,"_52":-5,"_53":-5,"_18":54,"_55":-5,"_56":48,"_57":-5,"_58":-5,"_59":60,"_61":62,"_63":64,"_65":66,"_67":68,"_69":70,"_71":72,"_73":72,"_74":75,"_76":75,"_77":75,"_78":72,"_79":72,"_80":81,"_82":83,"_84":85,"_86":24},"version",486,"changes",[19],"aiChatInfo","userId",{"_20":21,"_22":-7,"_23":24,"_25":24,"_26":27,"_28":27},"file",{"_29":30,"_31":32,"_33":34,"_35":36,"_37":38,"_39":14,"_40":41,"_23":24},"previous","deleted",false,"deletedHere","path","tests/raw-query.test.ts","latestPath","fileId","c79f492c-18ef-11f1-a6af-42dde27851f2","name","raw-query.test.ts","fileType","script","content","// Tests for rawQuery() — direct SQL execution that enables cross-table joins,\n// aggregations, CTEs, UNIONs, and any other SQL that single-table methods\n// cannot express.\n//\n// These tests use their own dedicated tables (_rawQueryUsers, _rawQueryPosts)\n// and are independent of the cumulative _testTable state in other suites.\n\nimport { assert, assertEqual } from \"./helpers.ts\";\nimport { _rawQueryUsers, _rawQueryPosts } from \"./fixtures.ts\";\n\nexport const rawQueryTests = [\n\n // ── Seed data ────────────────────────────────────────────────────────────\n\n async function rawQuerySeedData() {\n // Alice has 2 posts, Bob has 1, Charlie has none — intentional for join tests.\n await _rawQueryUsers.batchInsert([\n { id: 1, name: \"Alice\", score: 90 },\n { id: 2, name: \"Bob\", score: 50 },\n { id: 3, name: \"Charlie\", score: 70 },\n ]);\n await _rawQueryPosts.batchInsert([\n { id: 1, user_id: 1, title: \"Hello\" },\n { id: 2, user_id: 1, title: \"World\" },\n { id: 3, user_id: 2, title: \"Foo\" },\n ]);\n const userCount = await _rawQueryUsers.countRows();\n assertEqual(userCount, 3, \"seed: expected 3 users\");\n const postCount = await _rawQueryPosts.countRows();\n assertEqual(postCount, 3, \"seed: expected 3 posts\");\n },\n\n // ── Single-table SQL ─────────────────────────────────────────────────────\n\n async function rawQueryBasicSelect() {\n // rawQuery() should work for plain single-table SQL with a WHERE clause.\n const rows = await _rawQueryUsers.rawQuery(\n `SELECT * FROM _rawQueryUsers WHERE score > 60`,\n );\n // Alice (90) and Charlie (70) qualify; Bob (50) does not.\n assert(rows.length === 2, `expected 2 rows, got ${rows.length}`);\n const names = rows.map((r: any) => r.name).sort();\n assertEqual(names, [\"Alice\", \"Charlie\"], \"only high-scorers should be returned\");\n },\n\n async function rawQueryAggregation() {\n // COUNT and AVG should work across the table.\n const rows = await _rawQueryUsers.rawQuery(\n `SELECT COUNT(*) AS total, AVG(score) AS avg_score FROM _rawQueryUsers`,\n );\n assertEqual(rows[0].total, 3, \"total should be 3\");\n // (90 + 50 + 70) / 3 = 70\n assertEqual(rows[0].avg_score, 70, \"avg_score should be 70\");\n },\n\n async function rawQueryEmptyResult() {\n // A query matching nothing should return an empty array, not undefined or null.\n const rows = await _rawQueryUsers.rawQuery(\n `SELECT * FROM _rawQueryUsers WHERE id = 9999`,\n );\n assertEqual(rows, [], \"no-match query should return []\");\n },\n\n // ── Cross-table joins ────────────────────────────────────────────────────\n\n async function rawQueryInnerJoin() {\n // INNER JOIN returns only rows present in both tables.\n // Charlie has no posts so he should be excluded.\n const rows = await _rawQueryUsers.rawQuery(`\n SELECT _rawQueryUsers.name, _rawQueryPosts.title\n FROM _rawQueryUsers\n JOIN _rawQueryPosts ON _rawQueryUsers.id = _rawQueryPosts.user_id\n ORDER BY _rawQueryPosts.id\n `);\n assert(rows.length === 3, `INNER JOIN should return 3 rows, got ${rows.length}`);\n assertEqual(rows[0].name, \"Alice\", \"first joined row should be Alice\");\n assertEqual(rows[0].title, \"Hello\", \"first joined row should be 'Hello'\");\n const hasCharlie = rows.some((r: any) => r.name === \"Charlie\");\n assert(!hasCharlie, \"Charlie (no posts) should be excluded from INNER JOIN\");\n },\n\n async function rawQueryLeftJoin() {\n // LEFT JOIN includes all users, with null title where there is no matching post.\n const rows = await _rawQueryUsers.rawQuery(`\n SELECT _rawQueryUsers.name, _rawQueryPosts.title\n FROM _rawQueryUsers\n LEFT JOIN _rawQueryPosts ON _rawQueryUsers.id = _rawQueryPosts.user_id\n ORDER BY _rawQueryUsers.id, _rawQueryPosts.id\n `);\n // Alice×2 + Bob×1 + Charlie×1 (null) = 4 rows\n assert(rows.length === 4, `LEFT JOIN should return 4 rows, got ${rows.length}`);\n const charlie = rows.find((r: any) => r.name === \"Charlie\");\n assert(charlie !== undefined, \"Charlie should appear in LEFT JOIN result\");\n assertEqual(charlie.title, null, \"Charlie should have null title (no posts)\");\n },\n\n // ── Aggregation across tables ─────────────────────────────────────────────\n\n async function rawQueryGroupBy() {\n // Per-user post count via GROUP BY.\n const rows = await _rawQueryUsers.rawQuery(`\n SELECT _rawQueryUsers.name, COUNT(_rawQueryPosts.id) AS post_count\n FROM _rawQueryUsers\n LEFT JOIN _rawQueryPosts ON _rawQueryUsers.id = _rawQueryPosts.user_id\n GROUP BY _rawQueryUsers.id\n ORDER BY post_count DESC, _rawQueryUsers.name ASC\n `);\n assertEqual(rows.length, 3, \"GROUP BY should return one row per user\");\n assertEqual(rows[0].name, \"Alice\", \"Alice should have the most posts\");\n assertEqual(rows[0].post_count, 2, \"Alice should have 2 posts\");\n assertEqual(rows[2].post_count, 0, \"Charlie should have 0 posts\");\n },\n\n // ── CTEs ─────────────────────────────────────────────────────────────────\n\n async function rawQueryCTE() {\n // WITH (CTE) lets you name a subquery and reference it in the main query.\n const rows = await _rawQueryUsers.rawQuery(`\n WITH high_scorers AS (\n SELECT id, name FROM _rawQueryUsers WHERE score >= 70\n )\n SELECT high_scorers.name, _rawQueryPosts.title\n FROM high_scorers\n LEFT JOIN _rawQueryPosts ON high_scorers.id = _rawQueryPosts.user_id\n ORDER BY high_scorers.name, _rawQueryPosts.id\n `);\n // Alice (90, 2 posts) + Charlie (70, 0 posts) = 3 rows; Bob excluded\n assert(rows.length === 3, `CTE should return 3 rows, got ${rows.length}`);\n const names = rows.map((r: any) => r.name);\n assert(names.includes(\"Alice\"), \"Alice should be in CTE result\");\n assert(names.includes(\"Charlie\"), \"Charlie should be in CTE result\");\n assert(!names.includes(\"Bob\"), \"Bob (score 50) should be excluded by CTE filter\");\n },\n\n // ── UNION ─────────────────────────────────────────────────────────────────\n\n async function rawQueryUnion() {\n // UNION stacks results from two SELECT statements with matching column shapes.\n const rows = await _rawQueryUsers.rawQuery(`\n SELECT name AS label, 'user' AS kind FROM _rawQueryUsers\n UNION ALL\n SELECT title AS label, 'post' AS kind FROM _rawQueryPosts\n ORDER BY kind, label\n `);\n // 3 users + 3 posts = 6 total\n assertEqual(rows.length, 6, \"UNION ALL should return 6 rows\");\n const kinds = new Set(rows.map((r: any) => r.kind));\n assert(kinds.has(\"user\") && kinds.has(\"post\"), \"result should include both kinds\");\n },\n];\n","createdAt",["D",1772755355048],"branchVersion","branchId","29488f20-27b6-11f0-aecd-569c3dd06744","id","29484b28-27b6-11f0-aecd-569c3dd06744","SQLiteTable",["D",1746232377860],"deletedAt","legacyEnvVars",true,"privacy","public","httpPrivacy","description","imageUrl","f129b0f0-09bd-41ac-a51c-c16933d81d65","pinnedFileId","pinPreview","pinMigrated","screenshotVersion","likeCount",1,"orgId","5cdb635f-04df-409e-bb23-93b87a60f6ca","tursoName","29484b2827b611f0aecd569c3dd06744","tursoHostname","29484b2827b611f0aecd569c3dd06744-val-town.aws-us-east-2.turso.io","tursoMeasuredAt",["D",1789519256886],"pinned",0,"userPerm","r","valPerm","blobPerm","rw","emailPerm","sqlitePerm","projectPerm","telemetryPerm","user",{"_98":97,"_105":101},"org",{"_98":97,"_99":-5,"_100":101,"_18":54,"_102":103,"_104":24},"branch",{"_13":87,"_31":88,"_42":41,"_89":43,"_90":-5,"_91":-5,"_92":-5,"_93":-5,"_94":-5,"_95":44,"_96":97},"isOwned",509,"main","projectId","forkedBranchId","forkedBranchVersion","forkedProjectPrivacy","forkedProjectId","forkedProjectOrgId","projectName","userHandle","pql","handle","displayName","avatar","https://img.clerk.com/eyJ0eXBlIjoicHJveHkiLCJzcmMiOiJodHRwczovL2ltYWdlcy5jbGVyay5kZXYvdXBsb2FkZWQvaW1nXzJrYUVVM1VyRHRhckNnNGxidGEwUUdaSFRDYSJ9","tier","pro","canRestrictVals","profileImageUrl","branchName","","adoptOrgId",{"_42":43,"_31":44,"_37":373,"_46":-5,"_47":48,"_49":50,"_51":50,"_52":-5,"_53":-5,"_18":54,"_55":-5,"_56":48,"_57":-5,"_58":-5,"_59":60,"_61":62,"_63":64,"_65":66,"_67":374,"_69":70,"_71":72,"_73":72,"_74":75,"_76":75,"_77":75,"_78":72,"_79":72,"_80":375,"_82":376,"_84":377,"_86":24},"tree",[226,228,240,241,242,243,244,245,246,247],"files",[226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247],"counts",{"_216":70,"_217":60,"_218":70,"_219":220,"_221":222},"contents",[128,129,130,131,132,133,134,135,136,137],"upstreamProject","upstreamBranch","emptyEnvVars","flags",[],"hasHttpFiles","grants","orgs","customDomains",{},{"_42":210,"_31":211,"_29":212,"_141":-5,"_40":41,"_39":213,"_143":48,"_37":214,"_13":70,"_33":208,"_35":-5,"_23":24,"_147":-5,"_26":215},{"_42":203,"_31":204,"_29":205,"_141":-5,"_40":41,"_39":206,"_143":48,"_37":207,"_13":70,"_33":208,"_35":-5,"_23":24,"_147":-5,"_26":209},{"_42":196,"_31":197,"_29":198,"_141":-5,"_40":41,"_39":199,"_143":48,"_37":200,"_13":70,"_33":20,"_35":201,"_23":24,"_147":-5,"_26":202},{"_42":189,"_31":190,"_29":191,"_141":-5,"_40":41,"_39":192,"_143":48,"_37":193,"_13":70,"_33":20,"_35":194,"_23":24,"_147":-5,"_26":195},{"_42":181,"_31":182,"_29":183,"_141":-5,"_40":41,"_39":184,"_143":24,"_37":185,"_13":186,"_33":20,"_35":187,"_23":24,"_147":-5,"_26":188},{"_42":174,"_31":175,"_29":176,"_141":-5,"_40":41,"_39":177,"_143":48,"_37":178,"_13":70,"_33":20,"_35":179,"_23":24,"_147":-5,"_26":180},{"_42":165,"_31":166,"_29":167,"_141":-5,"_40":41,"_39":168,"_143":48,"_37":169,"_13":170,"_33":171,"_35":172,"_23":24,"_147":-5,"_26":173},{"_42":157,"_31":158,"_29":159,"_141":-5,"_40":41,"_39":160,"_143":24,"_37":161,"_13":162,"_33":34,"_35":163,"_23":24,"_147":-5,"_26":164},{"_42":149,"_31":150,"_29":151,"_141":-5,"_40":41,"_39":152,"_143":48,"_37":153,"_13":154,"_33":34,"_35":155,"_23":24,"_147":-5,"_26":156},{"_42":138,"_31":139,"_29":140,"_141":-5,"_40":41,"_39":142,"_143":24,"_37":144,"_13":145,"_33":34,"_35":146,"_23":24,"_147":-5,"_26":148},"d45d6276-17f4-11f1-9b31-42dde27851f2","utils","14f88bd6-68bd-11f0-9b48-0224a6c84d84","parentId",465,"latest",["D",1772647572721],28,"import { OpenAI } from \"https://esm.town/v/std/openai\";\n\n// ---- SHARED TYPES ---- //\n\n// Select conditions: key-value equalities (AND-joined) or raw SQL string\nexport type RowSelectCondition = object | string;\n\nexport type SelectOutputOptionsBase = {\n json?: boolean;\n columns?: string[];\n limit?: number;\n};\n\nexport type SelectOutputOptions = SelectOutputOptionsBase & (\n | { ascendBy?: string; descendBy?: never }\n | { descendBy?: string; ascendBy?: never }\n);\n\n\nexport type StreamOptions = {\n tableName?: string;\n batchSize?: number;\n stopAt?: number;\n};\n\n// ---- FUNCTIONS ---- //\n\nexport async function AISuggestCmd(plainText: string, tableName?: string): Promise {\n if (!plainText) return \"No prompt provided\";\n\n const tableSpecificSnippet = tableName ? `for a table named ${tableName}` : \"\";\n\n const decodedPrompt =\n `Give me just the sqlite command ${tableSpecificSnippet}, with no formatting or comments: ${plainText}`;\n\n // Initialize OpenAI\n const openai = new OpenAI();\n\n try {\n // Generate response using OpenAI\n const completion = await openai.chat.completions.create({\n messages: [\n { role: \"user\", content: decodedPrompt },\n ],\n max_tokens: 3000,\n });\n\n const [{ message: { content } }] = completion.choices;\n // Return the response as JSON\n console.log(\"AI suggestion: \", content);\n return content;\n } catch (error) {\n return \"Failed to generate response\";\n }\n}\n\nexport async function SQLiteTableInfo() {\n const { sqlite, name: tableName } = this;\n try {\n // First, verify the table exists\n const tableExists = await sqlite.execute(\n `SELECT name FROM sqlite_master WHERE type='table' AND name = ?`,\n [tableName],\n );\n\n if (tableExists.rows.length === 0) {\n throw new Error(`Table ${tableName} does not exist`);\n }\n\n // Get table-specific information\n const tableInfo = await sqlite.execute(`PRAGMA table_info(${tableName})`);\n\n // Count rows in the table\n const { rows: [{ row_count: rowCount }] } = await sqlite.execute(`SELECT COUNT(*) as row_count FROM ${tableName}`);\n\n // Get table size details using SQLite-specific queries\n const { rows: [{ page_size: pageSize }] } = await sqlite.execute(`PRAGMA page_size`);\n\n // Get page count for this specific table\n const { rows: [{ page_count: pageCount }] } = await sqlite.execute(\n `\n SELECT count(*) as page_count \n FROM sqlite_master \n WHERE type='table' AND name=? \n AND rootpage > 0\n `,\n [tableName],\n );\n\n // Estimate table size based on page count and page size\n const estimatedTableBytes = pageCount * pageSize;\n\n return {\n // tableName,\n columns: tableInfo.rows.map(({ name, type }) => ({ name, type })),\n rowCount,\n pageSize,\n pageCount,\n estimatedTableBytes,\n humanReadableSize: formatBytes(estimatedTableBytes),\n // indexes: indexInfoResult.rows.map(index => index.name),\n // indexCount: indexInfoResult.rows.length,\n };\n } catch (error) {\n return {\n error: `Error getting size for table ${tableName}: ${error.message}`,\n tableName,\n };\n }\n}\n\nfunction formatBytes(bytes: number, decimals = 2): string {\n if (bytes === 0) return \"0 Bytes\";\n\n const k = 1024;\n const dm = decimals < 0 ? 0 : decimals;\n const sizes = [\"Bytes\", \"KB\", \"MB\", \"GB\", \"TB\", \"PB\", \"EB\", \"ZB\", \"YB\"];\n\n const i = Math.floor(Math.log(bytes) / Math.log(k));\n\n return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + \" \" + sizes[i];\n}\n\n\n// Shared helper: collects all column names across records and serializes values to SQL literals.\n// Vector columns are inlined as vector('[...]') function calls rather than quoted strings.\nfunction buildColumnsAndValues(\n records: Record[],\n vectorColumns: Set = new Set(),\n): { columns: string[]; values: string } {\n if (!records || records.length === 0) {\n throw new Error(\"No records provided\");\n }\n const columns = Array.from(new Set(records.flatMap(record => Object.keys(record))));\n const values = records.map(record => {\n const rowValues = columns.map(col => {\n const value = record[col];\n if (value === undefined) return \"NULL\";\n if (vectorColumns.has(col)) return `vector('${JSON.stringify(value)}')`;\n return `'${String(value).replace(/'/g, \"''\")}'`;\n });\n return `(${rowValues.join(\", \")})`;\n }).join(\",\\n \");\n return { columns, values };\n}\n\n// Generates a bulk SQLite INSERT … ON CONFLICT upsert statement that MERGES records by conflictKey:\n// inserts new rows, updates existing rows only for fields explicitly provided, and preserves\n// existing values when incoming fields are missing (undefined). Requires a UNIQUE constraint\n// on conflictKey. Does not perform validation, type coercion, parameter binding, or per-row logic.\n\nexport const assembleBulkUpsertCommand = (\n tableName: string,\n records: Record[],\n conflictKey: string,\n vectorColumns?: Set,\n) => {\n if (!conflictKey) {\n throw new Error(\"Conflict key must be specified\");\n }\n\n const { columns, values } = buildColumnsAndValues(records, vectorColumns);\n\n if (!columns.includes(conflictKey)) {\n throw new Error(`Conflict key '${conflictKey}' not found in records`);\n }\n\n const nonConflictColumns = columns.filter(col => col !== conflictKey);\n\n return `\n INSERT INTO ${tableName} (${columns.join(\", \")})\n VALUES\n ${values}\n ON CONFLICT(${conflictKey}) DO UPDATE SET\n ${nonConflictColumns\n .map(col => `${col} = COALESCE(excluded.${col}, ${col})`)\n .join(\",\\n \")};\n `.trim();\n};\n\n\nexport const assembleBulkInsertCommand = (\n tableName: string,\n records: Record[],\n vectorColumns?: Set,\n): string => {\n const { columns, values } = buildColumnsAndValues(records, vectorColumns);\n\n return `\n INSERT INTO ${tableName} (${columns.join(\", \")})\n VALUES\n ${values};\n `.trim();\n};\n\nexport async function streamTableRows(\n processRowFn: (rows: Record[]) => void | Promise,\n options: StreamOptions = {},\n): Promise {\n const { sqlite } = this;\n const {\n tableName,\n batchSize = 1000,\n stopAt = Infinity,\n } = options;\n\n const KEY = \"SQLiteUtils\";\n const effectiveTableName = tableName || `${KEY}_rows`;\n\n try {\n if (!/^[a-zA-Z0-9_]+$/.test(effectiveTableName)) {\n throw new Error(\"Invalid table name. Only alphanumeric characters and underscores allowed.\");\n }\n\n let offset = 0;\n let batchCount = 0;\n\n while (batchCount < stopAt) {\n const query = `\n SELECT * FROM ${effectiveTableName}\n LIMIT ${batchSize}\n OFFSET ${offset}\n `;\n\n const result = await sqlite.execute(query);\n\n if (result.rows.length === 0) {\n break;\n }\n\n await processRowFn(result.rows);\n\n offset += batchSize;\n batchCount += 1;\n }\n\n return true;\n } catch (error) {\n console.error(\"Error streaming rows:\", error);\n throw error;\n }\n}\n\n// ---- HTTP ACCESS ---- //\n\nconst ALLOWED_OPERATIONS = [\n \"getRow\",\n \"getRows\",\n \"countRows\",\n \"getInfo\",\n] as const;\ntype AllowedOperation = typeof ALLOWED_OPERATIONS[number];\n\nexport async function http(req: Request): Promise {\n const url = new URL(req.url);\n console.log(url);\n const pathSegments = url.pathname.split(\"/\")\n .filter((segment) => segment.length > 0);\n\n const operation = pathSegments.at(-1) as AllowedOperation;\n\n if (!ALLOWED_OPERATIONS.includes(operation as AllowedOperation)) {\n return Response.json(\n {\n error: `Unknown operation: ${operation}. Supported operations: ${\n ALLOWED_OPERATIONS.join(\", \")\n }`,\n },\n { status: 400 },\n );\n }\n\n try {\n // Parse query params into select conditions.\n // Reserved params (prefixed with _) are treated as output options, not conditions.\n const conditions: Record = {};\n const outputOptions: SelectOutputOptions = { json: true };\n\n for (const [key, value] of url.searchParams.entries()) {\n if (key.startsWith(\"_\")) {\n const optionKey = key.slice(1) as keyof SelectOutputOptions;\n // Attempt to coerce numeric strings to numbers, otherwise treat as comma-split array or plain string\n if (value !== \"\" && !isNaN(Number(value))) {\n (outputOptions as any)[optionKey] = Number(value);\n } else if (value.includes(\",\")) {\n (outputOptions as any)[optionKey] = value.split(\",\").map((c) => c.trim());\n } else {\n (outputOptions as any)[optionKey] = value;\n }\n } else {\n // Attempt to coerce numeric strings to numbers\n const coerced = value !== \"\" && !isNaN(Number(value))\n ? Number(value)\n : value;\n conditions[key] = coerced;\n }\n }\n\n const hasConditions = Object.keys(conditions).length > 0;\n const args: any[] = [hasConditions ? conditions : undefined];\n if (operation !== \"countRows\") args.push(outputOptions);\n const result = await (this[operation] as Function)(...args);\n\n return Response.json(result ?? null);\n } catch (error) {\n console.error(`Error in ${operation} operation:`, error);\n return Response.json(\n { error: error.message || \"Internal server error\" },\n { status: 500 },\n );\n }\n}\n","label",[139],"86325642-1768-11f1-b529-42dde27851f2","tests.tsx","7701205e-0f93-11f1-a2bc-42dde27851f2",446,["D",1772587312058],17,"// Entry point — delegates to the modular test suite in tests/.\n// See tests/index.ts for the full runner and suite order.\nimport { runAllTests } from \"./tests/index.ts\";\n\nawait runAllTests();\n",[150],"37add50e-18ef-11f1-ae21-42dde27851f2","main.tsx","294acb64-27b6-11f0-aecd-569c3dd06744",482,["D",1772755113547],328,"import valSQLite, {\n sqlite as userSQLite,\n} from \"https://esm.town/v/std/sqlite/main.ts?v=14\";\n\nimport {\n AISuggestCmd,\n assembleBulkInsertCommand,\n assembleBulkUpsertCommand,\n http,\n RowSelectCondition,\n SelectOutputOptions,\n SQLiteTableInfo,\n StreamOptions,\n streamTableRows,\n} from \"./utils\";\n\ntype ColumnDefinition = string | {\n type?: \"integer\" | \"number\" | \"string\" | \"text\" | \"vector\";\n dimensions?: number; // required when type === \"vector\"\n primaryKey?: boolean;\n unique?: boolean;\n};\n\ntype TableScheme = { [key: string]: ColumnDefinition };\n\nexport class SQLiteTable {\n constructor(\n tableName: string,\n schema: TableScheme,\n options?: { scope?: \"user\" | \"val\" },\n ) {\n this.name = tableName;\n this.schema = schema;\n this.scope = options?.scope || \"user\";\n this.sqlite = this.scope === \"val\" ? valSQLite : userSQLite;\n return this;\n }\n\n name: string = \"newTable\";\n schema: TableScheme;\n scope: \"user\" | \"val\";\n sqlite: typeof userSQLite;\n\n async create() {\n const { name, schema } = this;\n await this.sqlite.execute(`create table if not exists ${name}(\n ${parseColumnDefinition(schema)}\n )`);\n }\n\n async drop() {\n const { name } = this;\n await this.sqlite.execute(`drop table ${name}`);\n }\n\n async exists() {\n const { name } = this;\n const table = await this.sqlite.execute(\n `SELECT * FROM sqlite_master WHERE type='table' AND name='${name}';`,\n );\n const { rows: [result] } = table;\n return result;\n }\n\n async getInfo() {\n return await SQLiteTableInfo.call(this);\n }\n\n async insertRow(rowData: object) {\n const { name, schema, sqlite } = this;\n const keys = Object.keys(rowData);\n\n const isVectorKey = (k: string) => isVectorColumnDef(schema[k]);\n\n const sql = `insert into ${name}(${keys.join(\", \")}) values (${\n keys.map((k) =>\n isVectorKey(k)\n ? `vector('${JSON.stringify((rowData as any)[k])}')`\n : `:${k}`\n ).join(\", \")\n })`;\n\n const args = Object.fromEntries(\n Object.entries(rowData).filter(([k]) => !isVectorKey(k)),\n );\n\n return await sqlite.execute({ sql, args });\n }\n\n async updateRow(conditions: RowSelectCondition, rowUpdate: object) {\n\n const { name, sqlite } = this;\n const rowUpdateString = stringifyEqualities(rowUpdate)\n .join(\", \\n\");\n const fullString = `UPDATE ${name} SET ${rowUpdateString}${\n formatConditions(conditions)\n }`;\n\n return await sqlite.execute(fullString);\n }\n\n async batchInsert(records: object[]) {\n const { name, sqlite, schema } = this;\n const fullString = assembleBulkInsertCommand(name, records, vectorColumnSet(schema));\n return await sqlite.execute(fullString);\n }\n\n async batchUpsert(records: object[], conflictKey: string) {\n const { name, sqlite, schema } = this;\n const fullString = assembleBulkUpsertCommand(name, records, conflictKey, vectorColumnSet(schema));\n return await sqlite.execute(fullString);\n }\n\n // get first matching row\n async getRow(\n conditions?: RowSelectCondition,\n outputOptions?: Pick,\n ) {\n return await this._selectQuery({\n conditions,\n outputOptions,\n single: true,\n });\n }\n\n // get all rows meeting a certain condition. option to return as an array of json objects\n async getRows(\n conditions?: RowSelectCondition,\n outputOptions?: SelectOutputOptions,\n ) {\n return await this._selectQuery({\n conditions,\n outputOptions,\n single: false,\n });\n }\n\n // count rows meeting a condition\n async countRows(conditions?: RowSelectCondition) {\n const { name, sqlite } = this;\n const { rows: [firstRow] } = await sqlite.execute(\n `select count(*) from ${name}${formatConditions(conditions)}`,\n );\n // rows may be objects (newer sqlite) or arrays (older sqlite)\n return Array.isArray(firstRow) ? firstRow[0] : Object.values(firstRow)[0];\n }\n\n // delete all rows meeting a condition\n async deleteRows(conditions?: RowSelectCondition) {\n const { name, sqlite } = this;\n return await sqlite.execute(\n `delete from ${name}${formatConditions(conditions)}`,\n );\n }\n\n async streamRowBatches(onBatch: Function, options?: Pick) {\n const { name } = this;\n return await streamTableRows.call(this, onBatch, {\n tableName: name,\n stopAt: options?.stopAt || Infinity,\n batchSize: 1000,\n });\n }\n\n /**\n * Add a new column to the table.\n * @param columnName name of the new column\n * @param columnScheme type and constraints for the new column\n */\n async addColumn(columnName: string, columnScheme: ColumnDefinition) {\n const { name, sqlite } = this;\n // parseColumnDefinition will return e.g. \"colName TEXT UNIQUE\"\n const colDef = parseColumnDefinition({ [columnName]: columnScheme });\n await sqlite.execute(`ALTER TABLE ${name} ADD COLUMN ${colDef}`);\n }\n\n /**\n * Remove a column from the table.\n * Requires SQLite 3.35.0 or later for native DROP COLUMN support.\n * @param columnName name of the column to drop\n */\n async removeColumn(columnName: string) {\n const { name, sqlite } = this;\n // SQLite 3.35+ supports: ALTER TABLE ... DROP COLUMN ...\n await sqlite.execute(`ALTER TABLE ${name} DROP COLUMN ${columnName}`);\n }\n\n /**\n * Get all indices for the table.\n */\n async getIndices() {\n const { name, sqlite } = this;\n const result = await sqlite.execute(\n `SELECT name, sql FROM sqlite_master WHERE type = 'index' AND tbl_name = '${name}'`,\n );\n return formatJSONOutput(result);\n }\n\n /**\n * Add an index to the table.\n * @param name name of the index\n * @param column column to index\n */\n async addIndex({ name, column }: { name: string; column: string }) {\n const { name: tableName, sqlite } = this;\n await sqlite.execute(\n `CREATE INDEX ${name} ON ${tableName} (${column})`,\n );\n }\n\n /**\n * Add a vector index (libsql_vector_idx) to a vector column.\n * The index is named `${tableName}_${column}_vidx` and is auto-discovered\n * by vectorSearch() — no need to track the name manually.\n * @param column name of the F32_BLOB column to index\n */\n async addVectorIndex(column: string) {\n const { name: tableName, sqlite } = this;\n const indexName = `${tableName}_${column}_vidx`;\n await sqlite.execute(\n `CREATE INDEX ${indexName} ON ${tableName} (libsql_vector_idx(${column}))`,\n );\n }\n\n /**\n * Search for the nearest neighbours to a query vector.\n * Automatically uses an ANN index if one exists (created via addVectorIndex),\n * otherwise falls back to a full table scan.\n * @param queryVector the query as a number array\n * @param column the vector column to search against\n * @param limit number of results to return (default 10)\n * @param forceFullScan skip index lookup and always use full scan\n */\n async vectorSearch({\n queryVector,\n column,\n limit = 10,\n forceFullScan = false,\n }: {\n queryVector: number[];\n column: string;\n limit?: number;\n forceFullScan?: boolean;\n }) {\n const { name: tableName, sqlite } = this;\n const vectorStr = JSON.stringify(queryVector);\n\n let indexName: string | null = null;\n if (!forceFullScan) {\n const result = await sqlite.execute(\n `SELECT name FROM sqlite_master WHERE type='index' AND tbl_name='${tableName}' AND sql LIKE '%libsql_vector_idx(${column})%'`,\n );\n indexName = (result.rows?.[0] as any)?.name ?? null;\n }\n\n const query = indexName\n ? `SELECT t.*, k.distance\n FROM vector_top_k('${indexName}', vector('${vectorStr}'), ${limit}) k\n JOIN ${tableName} t ON t.rowid = k.id`\n : `SELECT *, vector_distance_cos(${column}, vector('${vectorStr}')) AS distance\n FROM ${tableName}\n ORDER BY distance ASC\n LIMIT ${limit}`;\n\n return formatJSONOutput(await sqlite.execute(query));\n }\n\n /**\n * Execute a raw SQL string and return results as an array of plain objects.\n * This is the escape hatch for anything beyond single-table operations:\n * JOINs, GROUP BY, CTEs, UNIONs, or any other SQL that `getRows` can't express.\n *\n * @param sql A complete SQL statement. You are responsible for safe formatting.\n * @returns An array of plain JS objects (one per row), or [] if no rows match.\n *\n * @example\n * // Cross-table join\n * await users.rawQuery(`\n * SELECT users.name, posts.title\n * FROM users\n * JOIN posts ON users.id = posts.user_id\n * WHERE users.active = 1\n * `);\n *\n * @example\n * // Aggregation with GROUP BY\n * await users.rawQuery(`\n * SELECT users.name, COUNT(posts.id) AS post_count\n * FROM users LEFT JOIN posts ON users.id = posts.user_id\n * GROUP BY users.id\n * ORDER BY post_count DESC\n * `);\n */\n async rawQuery(sql: string): Promise {\n return formatJSONOutput(await this.sqlite.execute(sql));\n }\n\n async AISuggestCmd(plainText: string): Promise {\n const { name } = this;\n return await AISuggestCmd(plainText, name);\n }\n\n async http(req: Request): Promise {\n const bound = http.bind(this);\n return await bound(req);\n }\n\n private async _selectQuery({\n conditions,\n outputOptions = {},\n single = false,\n }: {\n conditions?: RowSelectCondition;\n outputOptions?: SelectOutputOptions;\n single?: boolean;\n }) {\n const { name, sqlite } = this;\n\n const columnL = outputOptions.columns?.length\n ? outputOptions.columns.join(\", \")\n : \"*\";\n\n let query = `select ${columnL} from ${name}${formatConditions(conditions)}`;\n\n if (single) {\n query += ` LIMIT 1`;\n } else {\n if (outputOptions.ascendBy) {\n query += ` ORDER BY ${outputOptions.ascendBy} ASC`;\n } else if (outputOptions.descendBy) {\n query += ` ORDER BY ${outputOptions.descendBy} DESC`;\n }\n\n if (outputOptions.limit != null) {\n query += ` LIMIT ${outputOptions.limit}`;\n }\n }\n\n const rawOutput = await sqlite.execute(query);\n\n // Non-JSON output\n if (!outputOptions.json) {\n return single ? (rawOutput.rows?.[0] ?? undefined) : rawOutput;\n }\n\n // JSON output\n const jsonRows = formatJSONOutput(rawOutput);\n return single ? (jsonRows[0] ?? undefined) : jsonRows;\n }\n}\n\nfunction formatJSONOutput(rawOutput) {\n if (!rawOutput) return [];\n const { rows, columns } = rawOutput;\n if (!rows?.length) return [];\n const json = rows.map((row) => {\n // rows may already be objects (newer sqlite lib versions)\n if (!Array.isArray(row)) return row;\n return Object.fromEntries(\n row.map((rowVal, rowValIndex) => [columns[rowValIndex], rowVal]),\n );\n });\n\n return json;\n}\n\nfunction parseColumnDefinition(scheme: TableScheme): string {\n return Object.entries(scheme)\n .map(([columnName, columnScheme]) => {\n // If user passed a raw string, trust it as-is\n if (typeof columnScheme === \"string\") {\n return `${columnName} ${columnScheme}`;\n }\n\n const parts: string[] = [];\n const type = columnScheme.type ?? \"text\";\n\n if (type === \"vector\") {\n if (!columnScheme.dimensions) {\n throw new Error(`Vector column \"${columnName}\" requires dimensions`);\n }\n parts.push(`F32_BLOB(${columnScheme.dimensions})`);\n } else {\n parts.push(type.toUpperCase());\n }\n\n if (columnScheme.primaryKey) parts.push(\"PRIMARY KEY\");\n if (columnScheme.unique) parts.push(\"UNIQUE\");\n\n return `${columnName} ${parts.join(\" \")}`;\n })\n .join(\",\\n\");\n}\n\nfunction stringifyEqualities(obj: Object): string[] {\n return Object.entries(obj).map(([key, value]) => {\n // Primitive: default to equality\n if (\n typeof value === \"string\" ||\n typeof value === \"number\" ||\n typeof value === \"boolean\" ||\n value === null\n ) {\n const keyValue = [key, formatValue(value)];\n return keyValue.join(value === null ? \" IS \" : \" = \");\n }\n\n // Operator object\n if (typeof value === \"object\" && value !== null) {\n const clauses = Object.entries(value).map(([op, val]) => {\n const formatted = formatValue(val);\n switch (op) {\n case \"greaterThan\":\n return `${key} > ${formatted}`;\n case \"atLeast\":\n return `${key} >= ${formatted}`;\n case \"lessThan\":\n return `${key} < ${formatted}`;\n case \"atMost\":\n return `${key} <= ${formatted}`;\n case \"notEqual\":\n return `${key} != ${formatted}`;\n case \"like\":\n return `${key} LIKE ${formatted}`;\n case \"in\": {\n if (!Array.isArray(val)) {\n throw new Error(`'in' expects an array for key \"${key}\"`);\n }\n if (val.length === 0) return \"0\"; // IN () is invalid; treat as always-false\n const list = val.map(formatValue).join(\", \");\n return `${key} IN (${list})`;\n }\n\n default:\n throw new Error(`Unsupported operator: ${op}`);\n }\n });\n return clauses.join(\" AND \");\n }\n\n throw new Error(`Invalid condition for key \"${key}\": ${value}`);\n });\n}\n\nfunction formatValue(value: any): string {\n if (typeof value === \"string\") return `'${sanitizeString(value)}'`;\n if (value === null) return \"NULL\";\n return String(value);\n}\n\nfunction formatConditions(conditions?: RowSelectCondition): string {\n if (!conditions) return \"\";\n if (typeof conditions === \"string\") return ` WHERE ${conditions}`;\n\n const conditionsString = stringifyEqualities(conditions)\n .join(\" AND \");\n return ` WHERE ${conditionsString}`;\n}\n\n// Escape single quotes by doubling them\n\nfunction sanitizeString(string: string): string {\n return string.replace(/'/g, \"''\");\n}\n\nfunction isVectorColumnDef(def: ColumnDefinition): boolean {\n if (typeof def === \"object\") return def?.type === \"vector\";\n if (typeof def === \"string\") return /^F32_BLOB\\(/i.test(def);\n return false;\n}\n\nfunction vectorColumnSet(schema: TableScheme): Set {\n return new Set(Object.keys(schema).filter((k) => isVectorColumnDef(schema[k])));\n}\n",[158],"aec51b48-0f94-11f1-8531-42dde27851f2","httpDemo.ts","281b626e-0d0a-11f1-a3a9-42dde27851f2",359,["D",1771726668666],7,"http","import { SQLiteTable } from \"./main.tsx\";\n\nconst table = new SQLiteTable(\"selftable\", { scope: \"val\" });\n\n// Learn more: https://docs.val.town/vals/http/\nexport default async function (req: Request): Promise {\n return await table.http(req);\n}",[166],"174202b6-1752-11f1-a16e-42dde27851f2","deno.json","1742036a-1752-11f1-a16e-42dde27851f2",425,["D",1772577677006],"{\n \"$schema\": \"https://raw.githubusercontent.com/denoland/deno/98f62cee78e85bfc47c62ed703777c6bc8794f1c/cli/schemas/config-file.v1.json\",\n \"lock\": false,\n \"compilerOptions\": {\n \"noImplicitAny\": false,\n \"strict\": true,\n \"types\": [\"https://www.val.town/types/valtown.d.ts\"],\n \"lib\": [\n \"dom\",\n \"dom.iterable\",\n \"dom.asynciterable\",\n \"deno.ns\",\n \"deno.unstable\"\n ]\n },\n \"lint\": {\n \"include\": [\"deno:/https/esm.town/**/*\"],\n \"rules\": {\n \"exclude\": [\"no-explicit-any\"]\n }\n },\n \"node_modules_dir\": false,\n \"experimental\": {\n \"unstable-node-globals\": true,\n \"unstable-temporal\": true,\n \"unstable-worker-options\": true,\n \"unstable-sloppy-imports\": true\n }\n}",[175],"d1a57c48-1831-11f1-bb9f-42dde27851f2","README.md","294ad15e-27b6-11f0-aecd-569c3dd06744",480,["D",1772673767477],34,"A thin abstraction over SQLite, to work with tables via JSON. Basic functionality for\n\n- Simple CRUD operations, intra-table\n- HTTP response handler for web reads\n- Streaming reads to iterate over large tables in batches\n- Store vector embeddings alongside data and do similarity search by nearest neighbour\n- Indices to optimize querying, and similarity search with ANN vector indices\n\n## Usage\n\n```javascript\nconst table = new SQLiteTable(\"myTable\", {\n id: \"unique primary key\",\n title: \"text\",\n body: \"text\",\n created: \"integer\",\n});\n\nawait table.create();\n```\n\n---\n\n# API\n\n## Basics\n\n#### `new SQLiteTable(name: string, schema: TableScheme, options?)`\n\nStart an instance of SQLiteTable. `schema` is a required object with column\nnames as keys and definitions as values — it is stored on the instance and used\nby `.create()`. See [TableScheme](#tablescheme) below for how to define columns.\n\n`options.scope` controls which SQLite database the table lives in:\n\n| Value | Database | Use when |\n| ------------------ | --------------------------- | --------------------------------------------------------------- |\n| `\"user\"` (default) | Shared across all your vals | Data should persist and be accessible from multiple vals |\n| `\"val\"` | Scoped to this val only | Data is private to this val, or you want isolation between vals |\n\n```javascript\n// User-scoped (default) — table is shared across your account\nconst table = new SQLiteTable(\"posts\", {\n id: \"unique primary key\",\n title: \"text\",\n});\n\n// Val-scoped — table is isolated to this val\nconst table = new SQLiteTable(\"posts\", { id: \"unique primary key\" }, {\n scope: \"val\",\n});\n```\n\n#### `.create()`\n\nCreate this table in your VT SQLite storage using the schema passed to the\nconstructor. Run this only once per table.\n\n#### `.drop()`\n\nDrop this table from your VT SQLite storage.\n\n#### `.exists()`\n\nReturns whether this table exists in storage.\n\n---\n\n## Write operations\n\n### `.insertRow(rowData)`\n\nAdd a new row to your table. `rowData` is a JSON with column names as keys, and\nrow values as values.\n\n```javascript\ntable.insertRow({\n id: 1234,\n title: \"Post title\",\n body: \"Post body\",\n created: 12345678,\n});\n```\n\n### `.deleteRows(conditions?)`\n\nDeletes all rows in the table that match the condition.\n\n### `.updateRow(conditions?, rowData)`\n\nModifies all rows in the table that match the condition. `rowData` is a JSON of\nkey-value pairs to change; it does not affect any columns not mentioned.\n\n```javascript\ntable.updateRow(\n { id: 1234 },\n {\n title:\n \"New title! The existing body text is not mentioned here so it is unaffected\",\n },\n);\n```\n\n---\n\n## Read operations\n\n### `.getInfo()`\n\nReturns metadata about the table:\n\n- `columns`: array of `{ name, type }` for each column\n- `rowCount`: total number of rows\n- `pageSize`, `pageCount`: SQLite page-level storage info\n- `estimatedTableBytes`, `humanReadableSize`: estimated table size on disk\n\n```javascript\nconst info = await table.getInfo();\n// {\n// columns: [{ name: \"id\", type: \"INTEGER\" }, { name: \"title\", type: \"TEXT\" }],\n// rowCount: 42,\n// humanReadableSize: \"4 KB\",\n// ...\n// }\n```\n\n### `.countRows(conditions?)`\n\nReturns a count of all rows in the table that match the condition.\n\nconditions: Either a JSON object of column conditions, or a raw SQL WHERE clause\nas a string. See [Conditions](#conditions) below.\n\n### `.getRow(conditions?, options?)`\n\nReturns the first row matching the given conditions.\n\n`options` is an optional [`SelectOutputOptionsBase`](#selectoutputoptionsbase) object.\n\n```javascript\ntable.getRow({ id: 1234 }, { json: true, columns: [\"id\", \"title\"] });\n```\n\n### `.getRows(conditions?, options?)`\n\nReturns all rows matching the given conditions.\n\n`options` is an optional [`SelectOutputOptions`](#selectoutputoptions) object, which extends `SelectOutputOptionsBase` with ordering.\n\n```javascript\n// Basic fetch\ntable.getRows({ status: \"active\" }, { json: true });\n\n// Sorted descending, limited\ntable.getRows({ status: \"active\" }, { json: true, descendBy: \"created\", limit: 10 });\n\n// Ascending, specific columns only\ntable.getRows(undefined, { json: true, ascendBy: \"score\", columns: [\"id\", \"score\"] });\n```\n\n### `.streamRowBatches(onBatch: Function)`\n\nIterate over all rows in batches of 1000, passing each batch to onBatch.\n\n```javascript\nawait table.streamRowBatches((batch) => {\n for (const row of batch) {\n console.log(row);\n }\n});\n```\n---\n\n## Output options\n\n### `SelectOutputOptionsBase`\n\nShared options accepted by both `.getRow()` and `.getRows()`:\n\n| Field | Type | Default | Description |\n| --------- | ---------- | ------- | -------------------------------------------------------- |\n| `json` | `boolean` | `false` | Return plain JS objects instead of raw DB output |\n| `columns` | `string[]` | — | Limit which columns are returned (defaults to all) |\n\n### `SelectOutputOptions`\n\nExtends `SelectOutputOptionsBase` with ordering options, accepted by `.getRows()`. `ascendBy` and `descendBy` are mutually exclusive.\n\n| Field | Type | Default | Description |\n| ----------- | -------- | ------- | ---------------------------------------------- |\n| `ascendBy` | `string` | — | Column name to sort by, ascending (`ASC`) |\n| `descendBy` | `string` | — | Column name to sort by, descending (`DESC`) |\n| `limit` | `number` | — | Maximum number of rows to return |\n\n\n---\n\n## Indices\n\n### `.getIndices()`\n\nReturns all indices on the table as an array of `{ name, sql }` objects.\n\n```javascript\nconst indices = await table.getIndices();\n// [{ name: \"idx_title\", sql: \"CREATE INDEX idx_title ON posts (title)\" }]\n```\n\n### `.addIndex({ name, column })`\n\nCreates an index on a single column. Note: there is no `IF NOT EXISTS` guard —\ncalling this twice with the same `name` will throw.\n\n```javascript\nawait table.addIndex({ name: \"idx_title\", column: \"title\" });\n```\n\n---\n\n## Vector embeddings\n\nSQLiteTable supports vector columns backed by libSQL's native `F32_BLOB` type,\nenabling similarity search directly in your SQLite database — no external vector\nstore required.\n\n### Defining a vector column\n\nIn object-form schema, set `type: \"vector\"` and provide `dimensions`:\n\n```javascript\nconst table = new SQLiteTable(\"articles\", {\n id: { type: \"integer\", primaryKey: true },\n content: { type: \"text\" },\n embedding: { type: \"vector\", dimensions: 1536 },\n});\n```\n\nString form also works and is passed through verbatim:\n\n```javascript\n{ embedding: \"F32_BLOB(1536)\" }\n```\n\n### Inserting vectors\n\nPass a plain `number[]` for vector columns. `insertRow`, `batchInsert`, and\n`batchUpsert` all handle the wrapping automatically:\n\n```javascript\nawait table.insertRow({\n id: 1,\n content: \"Hello world\",\n embedding: [0.1, 0.2, 0.3, /* ... */],\n});\n```\n\n### `.addVectorIndex(column)`\n\nCreates an ANN (Approximate Nearest Neighbour) index on a vector column using\nlibSQL's `libsql_vector_idx`. The index is named `${tableName}_${column}_vidx`\nand is auto-discovered by `vectorSearch()` — you never need to reference the\nname directly.\n\n```javascript\nawait table.addVectorIndex(\"embedding\");\n```\n\nCall this once after `create()`. Calling it again with the same column will throw.\n\n### `.vectorSearch({ queryVector, column, limit?, forceFullScan? })`\n\nReturns the nearest neighbours to a query vector, sorted by ascending distance.\nEach result includes a `distance` field alongside the row's normal columns.\n\n```javascript\nconst results = await table.vectorSearch({\n queryVector: [0.1, 0.2, 0.3, /* ... */],\n column: \"embedding\",\n limit: 5,\n});\n// [{ id: 1, content: \"Hello world\", embedding: ..., distance: 0.002 }, ...]\n```\n\n| Option | Type | Default | Description |\n| --------------- | ---------- | ------- | -------------------------------------------------------- |\n| `queryVector` | `number[]` | — | The query to search against |\n| `column` | `string` | — | The vector column to search |\n| `limit` | `number` | `10` | Maximum number of results to return |\n| `forceFullScan` | `boolean` | `false` | Skip the ANN index and use a full table scan instead |\n\nIf a vector index exists for the column (created via `addVectorIndex`), it is\nused automatically for ANN search via `vector_top_k`. Otherwise the query falls\nback to a full table scan using `vector_distance_cos`, which is accurate but\nslower for large tables (>10k rows).\n\n---\n\n## Web access\n\n### `.http(req: Request): Promise`\n\nExposes read operations (`getRow`, `getRows`, `countRows`, `getInfo`) as an HTTP\nhandler, so your table can be queried directly over the network. Useful for\nbuilding lightweight read APIs on top of your SQLite data without writing custom\nrouting logic.\n\nPass it as the handler in an HTTP val, bound to the table instance:\n\n```typescript\nimport { SQLiteTable } from \"https://esm.town/v/peterqliu/SQLiteTable/main.tsx\";\n\nconst table = new SQLiteTable(\"posts\", {\n id: \"unique primary key\",\n title: \"text\",\n});\n\nexport default (req: Request) => table.http(req);\n```\n\nThen query it via URL. The last path segment selects the operation, and query\nparams become row conditions:\n\n```\nGET /getRows?title=Hello\nGET /getRow?id=1234\nGET /countRows?created=12345678\n```\n\nUse `_columns` to limit which columns are returned:\n\n```\nGET /getRows?_columns=id,title\n```\n\n**Note:** Operators in object form are not available when using `.http()`. HTTP\nquery params only support simple equality conditions.\n\nUtilities\n\n### `.AISuggestCmd(plainText: string): Promise`\n\nUse AI to generate a suggested SQLite command for a given text description of\nyour intent.\n\n```javascript\nconst cmd = await table.AISuggestCmd(\n \"show me all active users sorted by join date\",\n);\n```\n\n---\n\n## TableScheme\n\nA `TableScheme` is a plain object where each key is a column name and each value\nis a column definition. Definitions can be provided in two forms:\n\n### String form\n\nPass a raw SQLite column definition string. The value is used verbatim, so you\nhave full control over type and constraints.\n\n```javascript\n{\n id: \"integer primary key\",\n title: \"text not null\",\n score: \"real default 0\",\n}\n```\n\n### Object form\n\nPass an object with the following optional fields:\n\n| Field | Type | Description |\n| ------------ | --------------------------------------------------------------------- | -------------------------------------------------------- |\n| `type` | `\"text\"` \\| `\"integer\"` \\| `\"number\"` \\| `\"string\"` \\| `\"vector\"` | Column type (defaults to `\"text\"`) |\n| `dimensions` | `number` | Number of dimensions — required when `type` is `\"vector\"` |\n| `primaryKey` | `boolean` | Adds `PRIMARY KEY` constraint |\n| `unique` | `boolean` | Adds `UNIQUE` constraint |\n\n```javascript\n{\n id: { type: \"integer\", primaryKey: true },\n email: { type: \"text\", unique: true },\n score: { type: \"number\" },\n bio: {}, // defaults to TEXT, no constraints\n}\n```\n\nBoth forms can be mixed freely in the same schema:\n\n```javascript\nconst table = new SQLiteTable(\"users\", {\n id: { type: \"integer\", primaryKey: true },\n email: { type: \"text\", unique: true },\n created: \"integer not null\",\n});\n```\n\n---\n\n## Conditions\n\nSome methods use a `conditions` argument to filter which rows are matched.\nConditions can be provided in two forms:\n\n### Object form (recommended)\n\nPass a plain JS object where each key is a column name. Multiple keys are joined\nwith `AND`.\n\n**Equality** (primitive value): matches rows where the column equals the value.\nA `null` value uses `IS NULL`.\n\n```javascript\ntable.getRows({ status: \"active\", score: 42 });\n// WHERE status = 'active' AND score = 42\n\ntable.getRows({ deleted_at: null });\n// WHERE deleted_at IS NULL\n```\n\n**Operator object**: for non-equality comparisons, set the value to an object\nwith one or more of the following operators. Multiple operators on the same key\nare also joined with `AND`.\n\n| Operator | SQL equivalent | Example |\n| ------------- | -------------- | ------------------------------------ |\n| `greaterThan` | `>` | `{ score: { greaterThan: 10 } }` |\n| `atLeast` | `>=` | `{ score: { atLeast: 10 } }` |\n| `lessThan` | `<` | `{ score: { lessThan: 100 } }` |\n| `atMost` | `<=` | `{ score: { atMost: 100 } }` |\n| `notEqual` | `!=` | `{ status: { notEqual: \"banned\" } }` |\n| `like` | `LIKE` | `{ title: { like: \"%hello%\" } }` |\n| `in` | `IN (...)` | `{ id: { in: [1, 2, 3] } }` |\n\n```javascript\n// Rows where score is between 10 and 100 (inclusive), and status is not \"banned\"\ntable.getRows({\n score: { atLeast: 10, atMost: 100 },\n status: { notEqual: \"banned\" },\n});\n\n// Rows where title contains \"hello\" (case-insensitive depends on collation)\ntable.getRows({ title: { like: \"%hello%\" } });\n\n// Rows where id is one of a set of values\ntable.getRows({ id: { in: [1, 2, 3] } });\n```\n\n### Raw SQL form\n\nPass a string to use a raw SQL `WHERE` clause directly. This gives you full\nSQLite expressiveness, but you are responsible for safe formatting.\n\n```javascript\ntable.getRows(\"created > 1700000000 OR pinned = 1\");\n```",[182],"173e166a-1752-11f1-b042-42dde27851f2","AGENTS.md","173e173c-1752-11f1-b042-42dde27851f2",424,["D",1772577676981],"You are an advanced assistant specialized in generating Val Town code.\n\n## Core Guidelines\n\n- Ask clarifying questions when requirements are ambiguous\n- Provide complete, functional solutions rather than skeleton implementations\n- Test your logic against edge cases before presenting the final solution\n- Ensure all code follows Val Town's specific platform requirements\n- If a section of code that you're working on is getting too complex, consider refactoring it into subcomponents\n\n## Code Standards\n\n- Generate code in TypeScript or TSX\n- Add appropriate TypeScript types and interfaces for all data structures\n- Prefer official SDKs or libraries than writing API calls directly\n- Ask the user to supply API or library documentation if you are at all unsure about it\n- **Never bake in secrets into the code** - always use environment variables\n- Include comments explaining complex logic (avoid commenting obvious operations)\n- Follow modern ES6+ conventions and functional programming practices if possible\n\n## Types of triggers\n\n### 1. HTTP Trigger\n\n- Create web APIs and endpoints\n- Handle HTTP requests and responses\n- Example structure:\n\n```ts\nexport default async function (req: Request) {\n return new Response(\"Hello World\");\n}\n```\n\nFiles that are HTTP triggers have http in their name like `foobar.http.tsx`\n\n### 2. Cron Triggers\n\n- Run on a schedule\n- Use cron expressions for timing\n- Example structure:\n\n```ts\nexport default async function () {\n // Scheduled task code\n}\n```\n\nFiles that are Cron triggers have cron in their name like `foobar.cron.tsx`\n\n### 3. Email Triggers\n\n- Process incoming emails\n- Handle email-based workflows\n- Example structure:\n\n```ts\nexport default async function (email: Email) {\n // Process email\n}\n```\n\nFiles that are Email triggers have email in their name like `foobar.email.tsx`\n\n\n## Val Town Standard Libraries\n\nVal Town provides several hosted services and utility functions.\n\n### Blob Storage\n\n```ts\nimport { blob } from \"https://esm.town/v/std/blob\";\nawait blob.setJSON(\"myKey\", { hello: \"world\" });\nlet blobDemo = await blob.getJSON(\"myKey\");\nlet appKeys = await blob.list(\"app_\");\nawait blob.delete(\"myKey\");\n```\n\n### SQLite\n\n```ts\nimport { sqlite } from \"https://esm.town/v/stevekrouse/sqlite\";\nconst TABLE_NAME = 'todo_app_users_2';\n// Create table - do this before usage and change table name when modifying schema\nawait sqlite.execute(`CREATE TABLE IF NOT EXISTS ${TABLE_NAME} (\n id INTEGER PRIMARY KEY AUTOINCREMENT,\n name TEXT NOT NULL\n)`);\n// Query data\nconst result = await sqlite.execute(`SELECT * FROM ${TABLE_NAME} WHERE id = ?`, [1]);\n```\n\nNote: When changing a SQLite table's schema, change the table's name (e.g., add _2 or _3) to create a fresh table.\n\n### OpenAI\n\n```ts\nimport { OpenAI } from \"https://esm.town/v/std/openai\";\nconst openai = new OpenAI();\nconst completion = await openai.chat.completions.create({\n messages: [\n { role: \"user\", content: \"Say hello in a creative way\" },\n ],\n model: \"gpt-4o-mini\",\n max_tokens: 30,\n});\n```\n\n### Email\n\n```ts\nimport { email } from \"https://esm.town/v/std/email\";\n// By default emails the owner of the val\nawait email({ \n subject: \"Hi\", \n text: \"Hi\", \n html: \"

Hi

\"\n});\n```\n\n## Val Town Utility Functions\n\nVal Town provides several utility functions to help with common project tasks.\n\n### Importing Utilities\n\nAlways import utilities with version pins to avoid breaking changes:\n\n```ts\nimport { parseProject, readFile, serveFile } from \"https://esm.town/v/std/utils@85-main/index.ts\";\n```\n\n### Available Utilities\n\n\n#### **serveFile** - Serve project files with proper content types\n\nFor example, in Hono:\n\n```ts\n// serve all files in frontend/ and shared/\napp.get(\"/frontend/*\", c => serveFile(c.req.path, import.meta.url));\napp.get(\"/shared/*\", c => serveFile(c.req.path, import.meta.url));\n```\n\n#### **readFile** - Read files from within the project:\n\n```ts\n// Read a file from the project\nconst fileContent = await readFile(\"/frontend/index.html\", import.meta.url);\n```\n\n#### **listFiles** - List all files in the project\n\n```ts\nconst files = await listFiles(import.meta.url);\n```\n\n#### **parseProject** - Extract information about the current project from import.meta.url\n\nThis is useful for including info for linking back to a val, ie in \"view source\" urls:\n\n```ts\nconst projectVal = parseProject(import.meta.url);\nconsole.log(projectVal.username); // Owner of the project\nconsole.log(projectVal.name); // Project name\nconsole.log(projectVal.version); // Version number\nconsole.log(projectVal.branch); // Branch name\nconsole.log(projectVal.links.self.project); // URL to the project page\n```\n\nHowever, it's *extremely importing* to note that `parseProject` and other Standard Library utilities ONLY RUN ON THE SERVER.\nIf you need access to this data on the client, run it in the server and pass it to the client by splicing it into the HTML page\nor by making an API request for it.\n\n## Val Town Platform Specifics\n\n- **Redirects:** Use `return new Response(null, { status: 302, headers: { Location: \"/place/to/redirect\" }})` instead of `Response.redirect` which is broken\n- **Images:** Avoid external images or base64 images. Use emojis, unicode symbols, or icon fonts/libraries instead\n- **AI Image:** To inline generate an AI image use: `

`\n- **Storage:** DO NOT use the Deno KV module for storage\n- **Browser APIs:** DO NOT use the `alert()`, `prompt()`, or `confirm()` methods\n- **Weather Data:** Use open-meteo for weather data (doesn't require API keys) unless otherwise specified\n- **View Source:** Add a view source link by importing & using `import.meta.url.replace(\"ems.sh\", \"val.town)\"` (or passing this data to the client) and include `target=\"_top\"` attribute\n- **Error Debugging:** Add `` to HTML to capture client-side errors\n- **Error Handling:** Only use try...catch when there's a clear local resolution; Avoid catches that merely log or return 500s. Let errors bubble up with full context\n- **Environment Variables:** Use `Deno.env.get('keyname')` when you need to, but generally prefer APIs that don't require keys\n- **Imports:** Use `https://esm.sh` for npm and Deno dependencies to ensure compatibility on server and browser\n- **Storage Strategy:** Only use backend storage if explicitly required; prefer simple static client-side sites\n- **React Configuration:** When using React libraries, pin versions with `?deps=react@18.2.0,react-dom@18.2.0` and start the file with `/** @jsxImportSource https://esm.sh/react@18.2.0 */`\n- Ensure all React dependencies and sub-dependencies are pinned to the same version\n- **Styling:** Default to using TailwindCSS via `` unless otherwise specified\n\n## Project Structure and Design Patterns\n\n### Recommended Directory Structure\n```\n├── backend/\n│ ├── database/\n│ │ ├── migrations.ts # Schema definitions\n│ │ ├── queries.ts # DB query functions\n│ │ └── README.md\n│ └── routes/ # Route modules\n│ ├── [route].ts\n│ └── static.ts # Static file serving\n│ ├── index.ts # Main entry point\n│ └── README.md\n├── frontend/\n│ ├── components/\n│ │ ├── App.tsx\n│ │ └── [Component].tsx\n│ ├── favicon.svg\n│ ├── index.html # Main HTML template\n│ ├── index.tsx # Frontend JS entry point\n│ ├── README.md\n│ └── style.css\n├── README.md\n└── shared/\n ├── README.md\n └── utils.ts # Shared types and functions\n```\n\n### Backend (Hono) Best Practices\n\n- Hono is the recommended API framework\n- Main entry point should be `backend/index.ts`\n- **Static asset serving:** Use the utility functions to read and serve project files:\n ```ts\n import { readFile, serveFile } from \"https://esm.town/v/std/utils@85-main/index.ts\";\n \n // serve all files in frontend/ and shared/\n app.get(\"/frontend/*\", c => serveFile(c.req.path, import.meta.url));\n app.get(\"/shared/*\", c => serveFile(c.req.path, import.meta.url));\n \n // For index.html, often you'll want to bootstrap with initial data\n app.get(\"/\", async c => {\n let html = await readFile(\"/frontend/index.html\", import.meta.url);\n \n // Inject data to avoid extra round-trips\n const initialData = await fetchInitialData();\n const dataScript = ``;\n \n html = html.replace(\"\", `${dataScript}`);\n return c.html(html);\n });\n ```\n- Create RESTful API routes for CRUD operations\n- Always include this snippet at the top-level Hono app to re-throwing errors to see full stack traces:\n ```ts\n // Unwrap Hono errors to see original error details\n app.onError((err, c) => {\n throw err;\n });\n ```\n\n### Database Patterns\n- Run migrations on startup or comment out for performance\n- Change table names when modifying schemas rather than altering\n- Export clear query functions with proper TypeScript typing\n\n## Common Gotchas and Solutions\n\n1. **Environment Limitations:** \n - Val Town runs on Deno in a serverless context, not Node.js\n - Code in `shared/` must work in both frontend and backend environments\n - Cannot use `Deno` keyword in shared code\n - Use `https://esm.sh` for imports that work in both environments\n\n2. **SQLite Peculiarities:**\n - Limited support for ALTER TABLE operations\n - Create new tables with updated schemas and copy data when needed\n - Always run table creation before querying\n\n3. **React Configuration:**\n - All React dependencies must be pinned to 18.2.0\n - Always include `@jsxImportSource https://esm.sh/react@18.2.0` at the top of React files\n - Rendering issues often come from mismatched React versions\n\n4. **File Handling:**\n - Val Town only supports text files, not binary\n - Use the provided utilities to read files across branches and forks\n - For files in the project, use `readFile` helpers\n\n5. **API Design:**\n - `fetch` handler is the entry point for HTTP vals\n - Run the Hono app with `export default app.fetch // This is the entry point for HTTP vals`\n\n",[190],"174b0a1e-1752-11f1-b042-42dde27851f2",".vtignore","174b0ac8-1752-11f1-b042-42dde27851f2",426,["D",1772577677068],".git\n.vscode\n.cursorrules\n.DS_Store\nnode_modules\nvendor",[197],"01db1fe6-1768-11f1-aed8-42dde27851f2","tests","01db20b8-1768-11f1-aed8-42dde27851f2",435,["D",1772587090024],"directory",[204],"d18aa2a6-1831-11f1-92a6-42dde27851f2",".claude","d18aa364-1831-11f1-92a6-42dde27851f2",478,["D",1772673767310],[211],"pulls","branches","forks","envVars",{"_223":70,"_225":70},"connections",{"_223":70,"_224":70},"count","unfilledCount","emptyCount",{"_42":210,"_31":211,"_29":212,"_141":-5,"_40":41,"_39":213,"_143":48,"_37":370,"_13":70,"_33":208,"_35":-5,"_23":24,"_147":-5,"_249":371,"_26":372},{"_42":362,"_31":363,"_29":364,"_141":212,"_40":41,"_39":365,"_143":24,"_37":366,"_13":339,"_33":20,"_35":367,"_23":24,"_147":-5,"_249":368,"_26":369},{"_42":203,"_31":204,"_29":205,"_141":-5,"_40":41,"_39":206,"_143":48,"_37":359,"_13":70,"_33":208,"_35":-5,"_23":24,"_147":-5,"_249":360,"_26":361},{"_42":351,"_31":352,"_29":353,"_141":205,"_40":41,"_39":354,"_143":48,"_37":355,"_13":70,"_33":34,"_35":356,"_23":24,"_147":-5,"_249":357,"_26":358},{"_42":343,"_31":344,"_29":345,"_141":205,"_40":41,"_39":346,"_143":48,"_37":347,"_13":70,"_33":34,"_35":348,"_23":24,"_147":-5,"_249":349,"_26":350},{"_42":334,"_31":335,"_29":336,"_141":205,"_40":41,"_39":337,"_143":48,"_37":338,"_13":339,"_33":34,"_35":340,"_23":24,"_147":-5,"_249":341,"_26":342},{"_42":326,"_31":327,"_29":328,"_141":205,"_40":41,"_39":329,"_143":48,"_37":330,"_13":70,"_33":34,"_35":331,"_23":24,"_147":-5,"_249":332,"_26":333},{"_42":318,"_31":319,"_29":320,"_141":205,"_40":41,"_39":321,"_143":24,"_37":322,"_13":70,"_33":34,"_35":323,"_23":24,"_147":-5,"_249":324,"_26":325},{"_42":310,"_31":311,"_29":312,"_141":205,"_40":41,"_39":313,"_143":48,"_37":314,"_13":70,"_33":34,"_35":315,"_23":24,"_147":-5,"_249":316,"_26":317},{"_42":306,"_31":32,"_29":30,"_141":205,"_40":41,"_39":14,"_143":24,"_37":307,"_13":70,"_33":34,"_35":36,"_23":24,"_147":-5,"_249":308,"_26":309},{"_42":298,"_31":299,"_29":300,"_141":205,"_40":41,"_39":301,"_143":48,"_37":302,"_13":70,"_33":34,"_35":303,"_23":24,"_147":-5,"_249":304,"_26":305},{"_42":290,"_31":291,"_29":292,"_141":205,"_40":41,"_39":293,"_143":48,"_37":294,"_13":70,"_33":34,"_35":295,"_23":24,"_147":-5,"_249":296,"_26":297},{"_42":282,"_31":283,"_29":284,"_141":205,"_40":41,"_39":285,"_143":48,"_37":286,"_13":70,"_33":34,"_35":287,"_23":24,"_147":-5,"_249":288,"_26":289},{"_42":273,"_31":274,"_29":275,"_141":205,"_40":41,"_39":276,"_143":48,"_37":277,"_13":278,"_33":34,"_35":279,"_23":24,"_147":-5,"_249":280,"_26":281},{"_42":196,"_31":197,"_29":198,"_141":-5,"_40":41,"_39":199,"_143":48,"_37":270,"_13":70,"_33":20,"_35":201,"_23":24,"_147":-5,"_249":271,"_26":272},{"_42":189,"_31":190,"_29":191,"_141":-5,"_40":41,"_39":192,"_143":48,"_37":267,"_13":70,"_33":20,"_35":194,"_23":24,"_147":-5,"_249":268,"_26":269},{"_42":181,"_31":182,"_29":183,"_141":-5,"_40":41,"_39":184,"_143":24,"_37":264,"_13":186,"_33":20,"_35":187,"_23":24,"_147":-5,"_249":265,"_26":266},{"_42":174,"_31":175,"_29":176,"_141":-5,"_40":41,"_39":177,"_143":48,"_37":261,"_13":70,"_33":20,"_35":179,"_23":24,"_147":-5,"_249":262,"_26":263},{"_42":165,"_31":166,"_29":167,"_141":-5,"_40":41,"_39":168,"_143":48,"_37":258,"_13":170,"_33":171,"_35":172,"_23":24,"_147":-5,"_249":259,"_26":260},{"_42":157,"_31":158,"_29":159,"_141":-5,"_40":41,"_39":160,"_143":24,"_37":255,"_13":162,"_33":34,"_35":163,"_23":24,"_147":-5,"_249":256,"_26":257},{"_42":149,"_31":150,"_29":151,"_141":-5,"_40":41,"_39":152,"_143":48,"_37":252,"_13":154,"_33":34,"_35":155,"_23":24,"_147":-5,"_249":253,"_26":254},{"_42":138,"_31":139,"_29":140,"_141":-5,"_40":41,"_39":142,"_143":24,"_37":248,"_13":145,"_33":34,"_35":146,"_23":24,"_147":-5,"_249":250,"_26":251},["D",1772647572721],"children",[],[139],["D",1772587312058],[],[150],["D",1772755113547],[],[158],["D",1771726668666],[],[166],["D",1772577677006],[],[175],["D",1772673767477],[],[182],["D",1772577676981],[],[190],["D",1772577677068],[],[197],"298bf716-17f6-11f1-bcc2-42dde27851f2","vector.test.ts","7336a2c8-1768-11f1-8448-42dde27851f2",472,["D",1772648145121],3,"// Tests for vector (F32_BLOB) column support:\n// • Object-form schema { type: \"vector\", dimensions: N } → stored as F32_BLOB(N)\n// • String-form schema \"F32_BLOB(N)\" passed verbatim\n// • insertRow() accepting a JS number array for vector columns\n// • batchInsert() / batchUpsert() with vector columns\n// • Error thrown when `dimensions` is missing from an object-form vector column\n//\n// Uses _testVectorTable (object-form) and _testVectorTableStr (string-form),\n// both created fresh in setup().\n\nimport { SQLiteTable } from \"../main.tsx\";\nimport { assert, assertEqual } from \"./helpers.ts\";\nimport { _testVectorTable, _testVectorTableStr } from \"./fixtures.ts\";\n\nexport const vectorTests = [\n\n async function vectorTableExists() {\n // The object-form vector table should have been created by setup().\n const result = await _testVectorTable.exists();\n assert(!!result, \"vector table should exist after create()\");\n },\n\n async function vectorColumnDefinedAsBlob() {\n // { type: \"vector\", dimensions: 3 } should be stored as F32_BLOB(3) in SQLite.\n const info = await _testVectorTable.getInfo();\n const embeddingCol = info.columns.find((c: any) => c.name === \"embedding\");\n assert(embeddingCol !== undefined, \"embedding column should exist\");\n assert(\n embeddingCol.type.toUpperCase().startsWith(\"F32_BLOB\"),\n `embedding column type should be F32_BLOB, got ${embeddingCol.type}`,\n );\n },\n\n async function insertRowWithVector() {\n // insertRow() should accept a JS array for a vector column and persist it.\n await _testVectorTable.insertRow({ id: 1, label: \"a\", embedding: [0.1, 0.2, 0.3] });\n const count = await _testVectorTable.countRows();\n assertEqual(count, 1, \"vector table should have 1 row after insert\");\n },\n\n async function insertRowVectorRowRetrievable() {\n // The inserted vector row should be retrievable by a non-vector condition.\n const count = await _testVectorTable.countRows({ id: 1 });\n assertEqual(count, 1, \"inserted vector row should be retrievable by id\");\n },\n\n async function insertRowMissingDimensionsThrows() {\n // Defining a vector column without `dimensions` is invalid; create() should\n // throw before making any database call.\n const badTable = new SQLiteTable(\n \"_badVectorTable\",\n { embedding: { type: \"vector\" } },\n { scope: \"val\" },\n );\n let threw = false;\n try {\n await badTable.create();\n } catch (_err) {\n threw = true;\n }\n assert(threw, \"vector column without dimensions should throw on create()\");\n },\n\n async function stringFormVectorInsert() {\n // A column defined as the raw string \"F32_BLOB(3)\" should also accept a\n // JS array on insert, just like the object-form equivalent.\n await _testVectorTableStr.insertRow({ id: 1, label: \"b\", embedding: [1.0, 2.0, 3.0] });\n const count = await _testVectorTableStr.countRows();\n assertEqual(count, 1, \"string-form vector table should have 1 row after insert\");\n },\n\n async function addVectorIndex() {\n // addVectorIndex() should create an index named __vidx.\n await _testVectorTable.addVectorIndex(\"embedding\");\n const indices = await _testVectorTable.getIndices();\n const found = indices.some((i: any) => i.name === \"_testVectorTable_embedding_vidx\");\n assert(found, \"vector index should appear in getIndices() with auto-generated name\");\n },\n\n async function vectorSearchFullScan() {\n // Seed two more rows so we have a meaningful nearest-neighbour result.\n // After prior tests, id=1 ([0.1, 0.2, 0.3]) already exists.\n await _testVectorTable.insertRow({ id: 2, label: \"close\", embedding: [1.0, 0.0, 0.0] });\n await _testVectorTable.insertRow({ id: 3, label: \"far\", embedding: [0.0, 0.0, 1.0] });\n\n // Query close to [1, 0, 0] — id=2 should be the nearest neighbour.\n const results = await _testVectorTable.vectorSearch({\n queryVector: [1.0, 0.1, 0.0],\n column: \"embedding\",\n limit: 3,\n forceFullScan: true,\n });\n\n assert(Array.isArray(results) && results.length > 0, \"vectorSearch should return results\");\n assert(\"distance\" in results[0], \"results should include a distance field\");\n assertEqual(results[0].id, 2, \"nearest neighbour should be id=2\");\n },\n\n async function vectorSearchUsesIndex() {\n // With the index created in addVectorIndex(), vectorSearch() should use ANN\n // (vector_top_k) automatically. We verify it returns results without error\n // and that the closest row is still id=2.\n const results = await _testVectorTable.vectorSearch({\n queryVector: [1.0, 0.1, 0.0],\n column: \"embedding\",\n limit: 3,\n });\n\n assert(Array.isArray(results) && results.length > 0, \"indexed vectorSearch should return results\");\n assertEqual(results[0].id, 2, \"indexed search: nearest neighbour should be id=2\");\n },\n\n async function batchInsertWithVectors() {\n // batchInsert() should wrap vector fields with vector() just like insertRow().\n // Table has ids 1-3 after prior tests; add ids 4 and 5.\n const before = await _testVectorTable.countRows();\n await _testVectorTable.batchInsert([\n { id: 4, label: \"d\", embedding: [0.5, 0.5, 0.0] },\n { id: 5, label: \"e\", embedding: [0.0, 0.5, 0.5] },\n ]);\n const after = await _testVectorTable.countRows();\n assertEqual(after, before + 2, \"batchInsert should add 2 vector rows\");\n },\n\n async function batchUpsertWithVectors() {\n // batchUpsert() should handle vector fields on both insert and update paths.\n // Update existing id=5 with a new vector, and insert new id=6.\n const before = await _testVectorTable.countRows();\n await _testVectorTable.batchUpsert([\n { id: 5, label: \"e-updated\", embedding: [0.1, 0.9, 0.0] },\n { id: 6, label: \"f\", embedding: [0.0, 0.1, 0.9] },\n ], \"id\");\n const after = await _testVectorTable.countRows();\n assertEqual(after, before + 1, \"batchUpsert should add 1 new row and update 1 existing\");\n const count5 = await _testVectorTable.countRows({ id: 5 });\n assertEqual(count5, 1, \"batchUpsert should not duplicate the updated row\");\n },\n];\n",[],[204,274],"63f28340-1768-11f1-ae72-42dde27851f2","string-schema.test.ts","63f2844e-1768-11f1-ae72-42dde27851f2",443,["D",1772587254600],"// Tests for string-form column definitions — schemas where each column value\n// is a raw SQL fragment string (e.g. \"integer primary key\", \"text not null\")\n// rather than a structured object.\n//\n// Verifies that constraint keywords embedded in the string (NOT NULL, PRIMARY KEY)\n// are honoured by the underlying SQLite engine.\n\nimport { assert, assertEqual } from \"./helpers.ts\";\nimport { _testTableStr } from \"./fixtures.ts\";\n\nexport const stringSchemaTests = [\n\n async function stringSchemaTableExists() {\n // The string-schema table should have been created successfully in setup().\n const result = await _testTableStr.exists();\n assert(!!result, \"string-schema table should exist after create()\");\n },\n\n async function stringSchemaCorrectColumns() {\n // getInfo() should report all three columns defined in the string schema.\n const info = await _testTableStr.getInfo();\n const colNames = info.columns.map((c: any) => c.name);\n assert(colNames.includes(\"id\"), \"string-schema table should have 'id' column\");\n assert(colNames.includes(\"label\"), \"string-schema table should have 'label' column\");\n assert(colNames.includes(\"value\"), \"string-schema table should have 'value' column\");\n },\n\n async function stringSchemaInsertAndGetRow() {\n // Basic insert + round-trip read to confirm the table functions normally.\n await _testTableStr.insertRow({ id: 1, label: \"alpha\", value: 1.5 });\n const row = await _testTableStr.getRow({ id: 1 }, { json: true });\n assertEqual(row, { id: 1, label: \"alpha\", value: 1.5 }, \"string-schema row mismatch\");\n },\n\n async function stringSchemaNotNullEnforced() {\n // 'label' is declared as \"text not null\"; omitting it should cause SQLite\n // to throw a constraint violation.\n let threw = false;\n try {\n await _testTableStr.insertRow({ id: 2, value: 3.14 });\n } catch (_err) {\n threw = true;\n }\n assert(threw, \"inserting a row without a NOT NULL column should throw\");\n },\n\n async function stringSchemaPrimaryKeyEnforced() {\n // 'id' is the primary key; a duplicate value should be rejected.\n let threw = false;\n try {\n await _testTableStr.insertRow({ id: 1, label: \"duplicate\", value: 0 });\n } catch (_err) {\n threw = true;\n }\n assert(threw, \"string-schema: duplicate primary key should throw\");\n },\n];\n",[],[204,283],"5941cb40-1768-11f1-8ee1-42dde27851f2","streaming.test.ts","5941cc12-1768-11f1-8ee1-42dde27851f2",442,["D",1772587236664],"// Tests for streamRowBatches() — the paginated async row-streaming method.\n// • Basic stream: total rows delivered across all batches equals countRows().\n// • stopAt option: limits the number of batches processed.\n\nimport { assertEqual } from \"./helpers.ts\";\nimport { _testTable } from \"./fixtures.ts\";\n\nexport const streamingTests = [\n\n async function streamRowBatches() {\n // The callback should receive every row in the table across one or more\n // batches; the cumulative count must match countRows().\n const batches: any[][] = [];\n await _testTable.streamRowBatches((rows: any[]) => {\n batches.push(rows);\n });\n const totalStreamed = batches.reduce((sum, b) => sum + b.length, 0);\n const count = await _testTable.countRows();\n assertEqual(totalStreamed, count, \"streamed row count should match total rows\");\n },\n\n async function streamRowBatchesStopAt() {\n // With batchSize=1000 and only a handful of rows the table fits in one\n // batch. stopAt:1 should therefore process exactly that one batch without\n // throwing or hanging.\n await _testTable.streamRowBatches(\n (_rows: any[]) => {},\n { stopAt: 1 },\n );\n // No error thrown = pass.\n },\n];\n",[],[204,291],"504709e2-1768-11f1-9cdf-42dde27851f2","schema.test.ts","50470b54-1768-11f1-9cdf-42dde27851f2",441,["D",1772587221594],"// Tests for schema-mutation methods on an existing table:\n// • addColumn — ALTER TABLE … ADD COLUMN\n// • removeColumn — ALTER TABLE … DROP COLUMN (requires SQLite 3.35+)\n//\n// These run after the query-options suite. The table has 5 rows at this point;\n// the tests do not change the row data, only the column structure.\n\nimport { assert } from \"./helpers.ts\";\nimport { _testTable } from \"./fixtures.ts\";\n\nexport const schemaTests = [\n\n async function addColumn() {\n // Adding a new column should make it visible in getInfo().columns.\n await _testTable.addColumn(\"tag\", { type: \"text\" });\n const info = await _testTable.getInfo();\n const colNames = info.columns.map((c: any) => c.name);\n assert(colNames.includes(\"tag\"), \"new 'tag' column should appear in getInfo\");\n },\n\n async function removeColumn() {\n // Dropping a column should remove it from getInfo().columns.\n await _testTable.removeColumn(\"tag\");\n const info = await _testTable.getInfo();\n const colNames = info.columns.map((c: any) => c.name);\n assert(!colNames.includes(\"tag\"), \"'tag' column should be gone after removeColumn\");\n },\n];\n",[],[204,299],"c79f4814-18ef-11f1-a6af-42dde27851f2",["D",1772755355048],[],[204,32],"47c0ba52-1768-11f1-8d8b-42dde27851f2","query-options.test.ts","47c0bb1a-1768-11f1-8d8b-42dde27851f2",440,["D",1772587207297],"// Tests for SelectOutputOptions passed to getRow() and getRows():\n// • No condition (return any row / all rows)\n// • Column projection via the `columns` option\n// • Ordering via `ascendBy` / `descendBy`\n// • Row cap via `limit`\n// • Combining options (columns + ordering, condition + ordering, etc.)\n// • Edge case: empty table returns [] / empty ResultSet\n//\n// NOTE: At entry the table may contain rows with null scores from the\n// conditions suite. getRowsEmptyTable() clears and re-seeds a clean set of\n// five rows that subsequent tests in this file rely on.\n\nimport { assert, assertEqual } from \"./helpers.ts\";\nimport { _testTable } from \"./fixtures.ts\";\n\nexport const queryOptionTests = [\n\n // ── getRow options ────────────────────────────────────────────────────────\n\n async function getRowNoCondition() {\n // Omitting a condition should return the first available row, not throw.\n const row = await _testTable.getRow(undefined, { json: true });\n assert(row !== undefined, \"getRow with no condition should return a row\");\n assert(\"id\" in row, \"returned row should have an 'id' field\");\n },\n\n async function getRowColumns() {\n // The `columns` option should limit which fields appear in the result.\n const row = await _testTable.getRow({ id: 1 }, {\n json: true,\n columns: [\"id\", \"name\"],\n });\n assert(row !== undefined, \"getRow with columns should return a row\");\n assert(\"id\" in row, \"row should have 'id'\");\n assert(\"name\" in row, \"row should have 'name'\");\n assert(!(\"score\" in row), \"row should not have 'score' when excluded via columns\");\n },\n\n // ── getRows edge cases ────────────────────────────────────────────────────\n\n async function getRowsEmptyTable() {\n // JSON output on an empty table should be an empty array.\n // Raw output should have a rows array of length 0.\n await _testTable.deleteRows();\n const rows = await _testTable.getRows(undefined, { json: true });\n assertEqual(rows, [], \"getRows on empty table should return []\");\n const raw = await _testTable.getRows();\n assert(raw.rows.length === 0, \"raw getRows on empty table should have 0 rows\");\n\n // Re-seed five rows for the remaining tests in this file.\n await _testTable.insertRow({ id: 1, name: \"Alice\", score: 42 });\n await _testTable.insertRow({ id: 2, name: \"Bob\", score: 99 });\n await _testTable.insertRow({ id: 3, name: \"Charlie\", score: 7 });\n await _testTable.insertRow({ id: 4, name: \"Dave\", score: 55 });\n await _testTable.insertRow({ id: 5, name: \"Eve\", score: 60 });\n },\n\n // ── limit ─────────────────────────────────────────────────────────────────\n\n async function getRowsLimitOnly() {\n // `limit` should cap the number of returned rows regardless of ordering.\n const rows = await _testTable.getRows(undefined, { json: true, limit: 2 });\n assertEqual(rows.length, 2, \"limit alone should cap results to 2 rows\");\n },\n\n // ── columns + ordering ────────────────────────────────────────────────────\n\n async function getRowsColumnsWithOrdering() {\n // Combining `columns` and `ascendBy` should both filter fields and sort.\n const rows = await _testTable.getRows(undefined, {\n json: true,\n ascendBy: \"score\",\n columns: [\"id\", \"score\"],\n });\n assert(rows.length > 1, \"should return multiple rows\");\n assert(!(\"name\" in rows[0]), \"name should be excluded via columns\");\n assert(\"score\" in rows[0], \"score should be present\");\n for (let i = 1; i < rows.length; i++) {\n assert(\n rows[i].score >= rows[i - 1].score,\n \"rows should be in ascending order by score\",\n );\n }\n },\n\n // ── freeform condition + ordering ─────────────────────────────────────────\n\n async function getRowsFreeformConditionWithOrdering() {\n // A raw SQL condition string and `descendBy` should compose correctly.\n const rows = await _testTable.getRows(\"score > 10\", {\n json: true,\n descendBy: \"score\",\n });\n assert(\n rows.every((r: any) => r.score > 10),\n \"all rows should satisfy score > 10\",\n );\n for (let i = 1; i < rows.length; i++) {\n assert(\n rows[i].score <= rows[i - 1].score,\n \"rows should be in descending order by score\",\n );\n }\n },\n\n // ── ascendBy ─────────────────────────────────────────────────────────────\n\n async function getRowsAscendBy() {\n // `ascendBy` should return all rows sorted lowest → highest.\n const rows = await _testTable.getRows(undefined, {\n json: true,\n ascendBy: \"score\",\n });\n assert(Array.isArray(rows) && rows.length > 1, \"ascendBy should return multiple rows\");\n for (let i = 1; i < rows.length; i++) {\n assert(\n rows[i].score >= rows[i - 1].score,\n `row ${i} score (${rows[i].score}) should be >= row ${i - 1} score (${rows[i - 1].score})`,\n );\n }\n },\n\n // ── descendBy ────────────────────────────────────────────────────────────\n\n async function getRowsDescendBy() {\n // `descendBy` should return all rows sorted highest → lowest.\n const rows = await _testTable.getRows(undefined, {\n json: true,\n descendBy: \"score\",\n });\n assert(Array.isArray(rows) && rows.length > 1, \"descendBy should return multiple rows\");\n for (let i = 1; i < rows.length; i++) {\n assert(\n rows[i].score <= rows[i - 1].score,\n `row ${i} score (${rows[i].score}) should be <= row ${i - 1} score (${rows[i - 1].score})`,\n );\n }\n },\n\n // ── ascendBy + limit ──────────────────────────────────────────────────────\n\n async function getRowsAscendByWithLimit() {\n // `ascendBy` combined with `limit` should return the N lowest-scored rows.\n const rows = await _testTable.getRows(undefined, {\n json: true,\n ascendBy: \"score\",\n limit: 2,\n });\n assertEqual(rows.length, 2, \"ascendBy with limit 2 should return 2 rows\");\n assert(rows[0].score <= rows[1].score, \"rows should be in ascending order\");\n },\n\n // ── descendBy + condition ─────────────────────────────────────────────────\n\n async function getRowsDescendByWithCondition() {\n // An operator condition and `descendBy` should both be applied together.\n const rows = await _testTable.getRows(\n { score: { greaterThan: 10 } },\n { json: true, descendBy: \"score\" },\n );\n assert(\n rows.every((r: any) => r.score > 10),\n \"all rows should satisfy score > 10\",\n );\n for (let i = 1; i < rows.length; i++) {\n assert(\n rows[i].score <= rows[i - 1].score,\n \"rows should be in descending order by score\",\n );\n }\n },\n];\n",[],[204,311],"7d78c0a4-1768-11f1-b41e-42dde27851f2","index.ts","7d78c176-1768-11f1-b41e-42dde27851f2",445,["D",1772587297420],"// Test runner — imports every suite and runs them in the correct sequential\n// order, then prints a summary.\n//\n// Suite execution order matters: the _testTable tests build cumulative state\n// across files (crud → conditions → query-options → schema → streaming).\n// String-schema and vector tests use their own tables and are independent.\n\nimport { runTest, TestResult } from \"./helpers.ts\";\nimport { setup, teardown } from \"./fixtures.ts\";\nimport { crudTests } from \"./crud.test.ts\";\nimport { conditionTests } from \"./conditions.test.ts\";\nimport { queryOptionTests } from \"./query-options.test.ts\";\nimport { schemaTests } from \"./schema.test.ts\";\nimport { streamingTests } from \"./streaming.test.ts\";\nimport { stringSchemaTests } from \"./string-schema.test.ts\";\nimport { vectorTests } from \"./vector.test.ts\";\n\nconst allTests = [\n // Core CRUD, raw output, index management — sequential state on _testTable\n ...crudTests,\n // WHERE clause condition operators and forms\n ...conditionTests,\n // getRow / getRows output options (ordering, limit, columns)\n ...queryOptionTests,\n // Schema mutation: addColumn / removeColumn\n ...schemaTests,\n // Paginated streaming via streamRowBatches()\n ...streamingTests,\n // String-form column definition schema (_testTableStr)\n ...stringSchemaTests,\n // Vector (F32_BLOB) column support (_testVectorTable, _testVectorTableStr)\n ...vectorTests,\n];\n\nexport async function runAllTests(): Promise {\n await setup();\n const results: TestResult[] = [];\n\n for (const test of allTests) {\n results.push(await runTest(test.name, test));\n }\n\n await teardown();\n\n const passed = results.filter((r) => r.passed).length;\n const failed = results.filter((r) => !r.passed);\n\n console.log(`\\n=== Test Results: ${passed}/${results.length} passed ===\\n`);\n for (const r of results) {\n const icon = r.passed ? \"✅\" : \"❌\";\n console.log(`${icon} ${r.name}`);\n }\n\n if (failed.length > 0) {\n console.log(`\\n=== ${failed.length} test(s) failed ===\\n`);\n for (const r of failed) {\n console.log(`❌ ${r.name}\\n ${r.error}\\n`);\n }\n throw new Error(`${failed.length} test(s) failed`);\n }\n}\n",[],[204,319],"01fac97c-1768-11f1-aed8-42dde27851f2","helpers.ts","01faca1c-1768-11f1-aed8-42dde27851f2",436,["D",1772587090234],"// Shared test utilities used by all test suites.\n\nexport type TestResult = { name: string; passed: boolean; error?: string };\n\n/** Throws if condition is false. */\nexport function assert(condition: boolean, message: string) {\n if (!condition) throw new Error(`Assertion failed: ${message}`);\n}\n\n/** Deep-equality check via JSON serialization; throws with a diff on mismatch. */\nexport function assertEqual(actual: any, expected: any, message: string) {\n const a = JSON.stringify(actual);\n const e = JSON.stringify(expected);\n if (a !== e) {\n throw new Error(`${message}\\n expected: ${e}\\n actual: ${a}`);\n }\n}\n\n/** Runs a single test function, catching errors and returning a result object. */\nexport async function runTest(\n name: string,\n fn: () => Promise,\n): Promise {\n try {\n await fn();\n return { name, passed: true };\n } catch (err) {\n return { name, passed: false, error: String(err) };\n }\n}\n",[],[204,327],"64604bfe-18ef-11f1-8622-42dde27851f2","fixtures.ts","0b1d38e6-1768-11f1-9138-42dde27851f2",485,["D",1772755188536],2,"// Shared table instances and setup / teardown logic used by all test suites.\n// Each table exercises a distinct part of the schema API.\n\nimport { SQLiteTable } from \"../main.tsx\";\n\n// Primary test table — object-form schema with integer PK, text, and numeric columns.\nexport const _testTable = new SQLiteTable(\n \"_testTable\",\n {\n id: { type: \"integer\", primaryKey: true },\n name: { type: \"text\" },\n score: { type: \"number\" },\n },\n { scope: \"val\" },\n);\n\n// Table defined with string-form column definitions (raw SQL fragments).\nexport const _testTableStr = new SQLiteTable(\n \"_testTableStr\",\n {\n id: \"integer primary key\",\n label: \"text not null\",\n value: \"real\",\n },\n { scope: \"val\" },\n);\n\n// Table with an object-form vector (F32_BLOB) column.\nexport const _testVectorTable = new SQLiteTable(\n \"_testVectorTable\",\n {\n id: { type: \"integer\", primaryKey: true },\n label: { type: \"text\" },\n embedding: { type: \"vector\", dimensions: 3 },\n },\n { scope: \"val\" },\n);\n\n// Tables used by rawQuery tests — a users/posts pair for join exercises.\nexport const _rawQueryUsers = new SQLiteTable(\n \"_rawQueryUsers\",\n {\n id: { type: \"integer\", primaryKey: true },\n name: { type: \"text\" },\n score: { type: \"number\" },\n },\n { scope: \"val\" },\n);\n\nexport const _rawQueryPosts = new SQLiteTable(\n \"_rawQueryPosts\",\n {\n id: { type: \"integer\", primaryKey: true },\n user_id: { type: \"integer\" },\n title: { type: \"text\" },\n },\n { scope: \"val\" },\n);\n\n// Table with a string-form vector column (\"F32_BLOB(3)\").\nexport const _testVectorTableStr = new SQLiteTable(\n \"_testVectorTableStr\",\n {\n id: { type: \"integer\", primaryKey: true },\n label: { type: \"text\" },\n embedding: \"F32_BLOB(3)\",\n },\n { scope: \"val\" },\n);\n\n/** Drop any leftover tables from a previous failed run, then (re-)create them. */\nexport async function setup() {\n if (await _testTable.exists()) await _testTable.drop();\n await _testTable.create();\n\n if (await _testTableStr.exists()) await _testTableStr.drop();\n await _testTableStr.create();\n\n if (await _testVectorTable.exists()) await _testVectorTable.drop();\n await _testVectorTable.create();\n\n if (await _testVectorTableStr.exists()) await _testVectorTableStr.drop();\n await _testVectorTableStr.create();\n\n if (await _rawQueryUsers.exists()) await _rawQueryUsers.drop();\n await _rawQueryUsers.create();\n\n if (await _rawQueryPosts.exists()) await _rawQueryPosts.drop();\n await _rawQueryPosts.create();\n}\n\n/** Drop all test tables after a run. */\nexport async function teardown() {\n if (await _testTable.exists()) await _testTable.drop();\n if (await _testTableStr.exists()) await _testTableStr.drop();\n if (await _testVectorTable.exists()) await _testVectorTable.drop();\n if (await _testVectorTableStr.exists()) await _testVectorTableStr.drop();\n if (await _rawQueryUsers.exists()) await _rawQueryUsers.drop();\n if (await _rawQueryPosts.exists()) await _rawQueryPosts.drop();\n}\n",[],[204,335],"2287db4e-1768-11f1-9cdf-42dde27851f2","crud.test.ts","2287dc02-1768-11f1-9cdf-42dde27851f2",438,["D",1772587144846],"// Tests for core CRUD operations on the primary test table:\n// insertRow, getRow, getRows, countRows, updateRow, batchInsert, batchUpsert,\n// deleteRows, getInfo, addIndex / getIndices, and raw (non-JSON) output.\n//\n// NOTE: These tests run sequentially and share cumulative table state — each\n// test assumes the rows left by the previous ones are still present.\n\nimport { assert, assertEqual } from \"./helpers.ts\";\nimport { _testTable } from \"./fixtures.ts\";\n\nexport const crudTests = [\n\n // ── Table lifecycle ──────────────────────────────────────────────────────\n\n async function tableExists() {\n // create() should have been called in setup(); verify the table is live.\n const result = await _testTable.exists();\n assert(!!result, \"table should exist after create()\");\n },\n\n // ── Single-row insert & retrieval ────────────────────────────────────────\n\n async function insertAndGetRow() {\n // Insert one row and round-trip it through getRow with JSON output.\n await _testTable.insertRow({ id: 1, name: \"Alice\", score: 42 });\n const row = await _testTable.getRow({ id: 1 }, { json: true });\n assertEqual(row, { id: 1, name: \"Alice\", score: 42 }, \"inserted row mismatch\");\n },\n\n // ── Multi-row read ───────────────────────────────────────────────────────\n\n async function getRows() {\n // Add two more rows; total should be 3.\n await _testTable.insertRow({ id: 2, name: \"Bob\", score: 99 });\n await _testTable.insertRow({ id: 3, name: \"Charlie\", score: 7 });\n const rows = await _testTable.getRows(undefined, { json: true });\n assert(rows.length === 3, `expected 3 rows, got ${rows.length}`);\n },\n\n // ── Row count ────────────────────────────────────────────────────────────\n\n async function countRows() {\n // Confirm the unconditional count matches the number of inserts so far.\n const count = await _testTable.countRows();\n assertEqual(count, 3, \"countRows should return 3\");\n },\n\n async function countRowsWithCondition() {\n // Alice(42) and Bob(99) both have score > 10; Charlie(7) does not.\n const count = await _testTable.countRows({ score: { greaterThan: 10 } });\n assertEqual(count, 2, \"rows with score > 10 should be 2\");\n },\n\n // ── Update ───────────────────────────────────────────────────────────────\n\n async function updateRow() {\n // Update a single column on an existing row and verify the change.\n await _testTable.updateRow({ id: 1 }, { score: 100 });\n const row = await _testTable.getRow({ id: 1 }, { json: true });\n assertEqual(row?.score, 100, \"score should be updated to 100\");\n },\n\n // ── Batch insert ─────────────────────────────────────────────────────────\n\n async function batchInsert() {\n // Insert multiple rows in a single call; total should grow to 5.\n await _testTable.batchInsert([\n { id: 4, name: \"Dave\", score: 55 },\n { id: 5, name: \"Eve\", score: 60 },\n ]);\n const count = await _testTable.countRows();\n assertEqual(count, 5, \"batchInsert: total rows should be 5\");\n },\n\n // ── Batch upsert ─────────────────────────────────────────────────────────\n\n async function batchUpsert() {\n // id=1 already exists → its score should be updated to 200.\n // id=6 is new → it should be inserted, bringing the total to 6.\n await _testTable.batchUpsert(\n [\n { id: 1, name: \"Alice\", score: 200 },\n { id: 6, name: \"Frank\", score: 11 },\n ],\n \"id\",\n );\n const alice = await _testTable.getRow({ id: 1 }, { json: true });\n assertEqual(alice?.score, 200, \"upserted alice score should be 200\");\n const count = await _testTable.countRows();\n assertEqual(count, 6, \"batchUpsert: total rows should be 6\");\n },\n\n // ── Table info ───────────────────────────────────────────────────────────\n\n async function getInfo() {\n // getInfo() should return column metadata and the current row count.\n const info = await _testTable.getInfo();\n assert(typeof info === \"object\" && info !== null, \"getInfo should return an object\");\n assert(Array.isArray(info.columns), \"getInfo.columns should be an array\");\n const names = info.columns.map((c: any) => c.name);\n assert(names.includes(\"id\"), \"getInfo should include 'id' column\");\n assert(names.includes(\"name\"), \"getInfo should include 'name' column\");\n assert(names.includes(\"score\"), \"getInfo should include 'score' column\");\n assert(typeof info.rowCount === \"number\", \"getInfo.rowCount should be a number\");\n },\n\n // ── Index management ─────────────────────────────────────────────────────\n\n async function addIndexAndGetIndices() {\n // Create a named index on 'score' and verify it appears in getIndices().\n await _testTable.addIndex({ name: \"_testTable_score_idx\", column: \"score\" });\n const indices = await _testTable.getIndices();\n assert(Array.isArray(indices), \"getIndices should return an array\");\n const found = indices.some((i: any) => i.name === \"_testTable_score_idx\");\n assert(found, \"created index should appear in getIndices()\");\n },\n\n // ── Column projection ────────────────────────────────────────────────────\n\n async function selectColumns() {\n // Passing a columns list should exclude unlisted columns from results.\n const rows = await _testTable.getRows(undefined, {\n json: true,\n columns: [\"id\", \"name\"],\n });\n assert(rows.length > 0, \"should return rows\");\n assert(!(\"score\" in rows[0]), \"score column should be excluded\");\n assert(\"name\" in rows[0], \"name column should be present\");\n },\n\n // ── Constraint enforcement ───────────────────────────────────────────────\n\n async function insertRowDuplicateKeyThrows() {\n // The integer primary key should reject a duplicate value.\n await _testTable.insertRow({ id: 99, name: \"Unique\", score: 1 });\n let threw = false;\n try {\n await _testTable.insertRow({ id: 99, name: \"Duplicate\", score: 2 });\n } catch (_err) {\n threw = true;\n }\n assert(threw, \"inserting a duplicate primary key should throw\");\n },\n\n // ── Delete ───────────────────────────────────────────────────────────────\n\n async function deleteRowsWithCondition() {\n // Conditional delete should remove exactly the matching rows.\n const before = await _testTable.countRows();\n await _testTable.deleteRows({ id: 6 });\n const after = await _testTable.countRows();\n assertEqual(after, before - 1, \"deleteRows should remove exactly 1 row\");\n const gone = await _testTable.getRow({ id: 6 }, { json: true });\n assertEqual(gone, undefined, \"deleted row should not be retrievable\");\n },\n\n async function deleteAllRows() {\n // Calling deleteRows() with no condition should truncate the table.\n await _testTable.deleteRows();\n const count = await _testTable.countRows();\n assertEqual(count, 0, \"deleteRows() with no condition should clear the table\");\n },\n\n // ── Raw (non-JSON) output ────────────────────────────────────────────────\n\n async function getRawRow() {\n // Without { json: true }, getRow() returns the raw sqlite row object.\n await _testTable.insertRow({ id: 1, name: \"Alice\", score: 42 });\n const row = await _testTable.getRow({ id: 1 });\n assert(row !== undefined, \"raw getRow should return a result\");\n assert(\"id\" in row, \"raw row should have 'id' key\");\n },\n\n async function getRawRows() {\n // Without { json: true }, getRows() returns the raw ResultSet object\n // with 'rows' and 'columns' properties rather than a plain array.\n const result = await _testTable.getRows();\n assert(result !== undefined, \"raw getRows should return a result\");\n assert(\"rows\" in result, \"raw getRows result should have a 'rows' property\");\n assert(\"columns\" in result, \"raw getRows result should have a 'columns' property\");\n },\n\n async function getRowMiss() {\n // getRow() should return undefined when no row matches the condition.\n const row = await _testTable.getRow({ id: 9999 }, { json: true });\n assertEqual(row, undefined, \"getRow with no match should return undefined\");\n },\n];\n",[],[204,344],"3321634e-1768-11f1-ade9-42dde27851f2","conditions.test.ts","3321643e-1768-11f1-ade9-42dde27851f2",439,["D",1772587172694],"// Tests for WHERE clause condition forms supported by RowSelectCondition:\n// • Comparison operators: greaterThan, atLeast, lessThan, atMost, notEqual\n// • Pattern matching: like\n// • Set membership: in (non-empty and empty array)\n// • Null equality: { column: null } → IS NULL\n// • Freeform SQL string passed directly as the condition\n//\n// NOTE: These tests run after crud.test.ts. At entry the table contains\n// exactly one row: { id:1, name:\"Alice\", score:42 }.\n// Additional rows are seeded inside the suite and left in place for subsequent\n// test files (query-options.test.ts expects the same five rows).\n\nimport { assert, assertEqual } from \"./helpers.ts\";\nimport { _testTable } from \"./fixtures.ts\";\n\nexport const conditionTests = [\n\n async function conditionOperators() {\n // Seed rows so we have a spread of score values to test operators against.\n await _testTable.insertRow({ id: 2, name: \"Bob\", score: 99 });\n await _testTable.insertRow({ id: 3, name: \"Charlie\", score: 7 });\n await _testTable.insertRow({ id: 4, name: \"Dave\", score: 55 });\n await _testTable.insertRow({ id: 5, name: \"Eve\", score: 60 });\n // Scores: Alice=42, Bob=99, Charlie=7, Dave=55, Eve=60\n\n // atLeast (>=) — Dave(55), Bob(99), Eve(60)\n const gte = await _testTable.countRows({ score: { atLeast: 55 } });\n assertEqual(gte, 3, \"atLeast 55: expected 3 rows\");\n\n // lessThan (<) — Alice(42), Charlie(7)\n const lt = await _testTable.countRows({ score: { lessThan: 55 } });\n assertEqual(lt, 2, \"lessThan 55: expected 2 rows\");\n\n // atMost (<=) — Alice(42), Charlie(7), Dave(55)\n const lte = await _testTable.countRows({ score: { atMost: 55 } });\n assertEqual(lte, 3, \"atMost 55: expected 3 rows\");\n\n // notEqual (!=) — everyone except Alice(42)\n const ne = await _testTable.countRows({ score: { notEqual: 42 } });\n assertEqual(ne, 4, \"notEqual 42: expected 4 rows\");\n\n // like — only Alice starts with 'A'\n const like = await _testTable.getRows({ name: { like: \"A%\" } }, { json: true });\n assertEqual(like.length, 1, \"LIKE 'A%': expected 1 row\");\n assertEqual(like[0].name, \"Alice\", \"LIKE 'A%': expected Alice\");\n\n // in — rows with id 1 or 3\n const inList = await _testTable.getRows({ id: { in: [1, 3] } }, { json: true });\n assertEqual(inList.length, 2, \"IN [1,3]: expected 2 rows\");\n\n // in with empty array — IN () is invalid SQL; the library should treat it\n // as an always-false condition and return 0 rows without erroring.\n const inEmpty = await _testTable.countRows({ id: { in: [] } });\n assertEqual(inEmpty, 0, \"IN []: expected 0 rows\");\n },\n\n async function conditionNullEquality() {\n // Passing null as a column value should generate IS NULL (not = NULL).\n await _testTable.insertRow({ id: 10, name: \"Null Score\" });\n const nullRows = await _testTable.getRows({ score: null }, { json: true });\n assertEqual(nullRows.length, 1, \"IS NULL: expected 1 row with null score\");\n assertEqual(nullRows[0].id, 10, \"IS NULL: expected row id=10\");\n },\n\n async function conditionStringFreeform() {\n // A raw SQL string can be passed as the condition instead of an object.\n const rows = await _testTable.getRows(\"score > 50\", { json: true });\n assert(rows.length > 0, \"freeform string condition should return results\");\n assert(\n rows.every((r: any) => r.score > 50),\n \"all rows should satisfy score > 50\",\n );\n },\n];\n",[],[204,352],["D",1772587090024],[229,230,231,232,233,234,235,236,237,238,239],[204],"3c057b70-18ef-11f1-9872-42dde27851f2","settings.local.json","d19c4150-1831-11f1-b04c-42dde27851f2",483,["D",1772755120830],"{\n \"permissions\": {\n \"allow\": [\n \"mcp__claude_ai_valtown__list_files\",\n \"mcp__claude_ai_valtown__read_file\",\n \"WebFetch(domain:turso.tech)\"\n ]\n }\n}\n",[],[211,363],["D",1772673767310],[227],[211],["D",1746232377860],["D",1789519256886],{"_98":97,"_105":101},{"_98":97,"_99":-5,"_100":101,"_18":54,"_102":103,"_104":24},{"_13":87,"_31":88,"_42":41,"_89":43,"_90":-5,"_91":-5,"_92":-5,"_93":-5,"_94":-5,"_95":44,"_96":97},"ctx",{"_80":-5,"_125":411,"_412":413,"_414":415,"_416":24,"_417":24,"_418":24,"_419":48,"_420":-5,"_421":-7,"_422":-7,"_423":70,"_424":24,"_425":24,"_426":-5,"_427":24,"_428":24,"_429":24,"_430":-5},"ENV",{"_382":383,"_384":385,"_386":88,"_387":388,"_389":390,"_391":392,"_393":394,"_395":396,"_397":398,"_399":400,"_401":402,"_403":404,"_405":406,"_407":408,"_409":410},"REACT_APP_SENTRY_DSN","https://586020d86f05489db63a554690acf1e9@o1398359.ingest.sentry.io/6724499","RENDER_GIT_COMMIT","e87eb04e707cf64e7e532c8e8ec395f209e17f15","RENDER_GIT_BRANCH","POSTHOG_API_TOKEN","phc_nmoyuAkStEZuUp69rYlg1DZgrIt19Gx0Y4Hwf8tGgJP","POSTHOG_API_HOST","https://wart.val.town","WEB_API_TEMPLATE","https://{val}.web.val.run","APP_URL","https://www.val.town","MODULE_URL","https://esm.town","VANITY_WEB_API_TEMPLATE","https://{label}.val.run/","DENOLS_URL","https://lsp.val.town","NODE_ENV","production","CLOUDFLARE_TURNSTILE_SITE_KEY","0x4AAAAAACtaIZJH7s9rBMZ6","GOOGLE_CLIENT_ID","875989696899-jtsqkhlbdv5jrlsk8631p7ipjg3c6o62.apps.googleusercontent.com","STRIPE_PUBLISHABLE_KEY","pk_live_51N2zvWEpZTTLipIkVEwXrUG9AT0yeOOEYxszarZT1jpsZV58Ly6wlg3SltZpHN26CUalOBmUSY7adQRQiSkCZz2500qSXNkf8Y","API_URL","https://api.val.town",[],"preferencesKeybindings","default","preferencesTheme","light","preferencesFixers","preferencesCopilot","preferencesSelectionAi","preferencesCloseBrackets","preferencesChatPanelState","preferencesDprint","preferencesDenofmt","notificationCount","flagDenols","isBusinessOrgMember","businessOrgHandle","isBusinessOrgAdmin","isHigherTownieTier","navCollapsed","currentOrgId"]

Diff · v486