@promptbook/cli 0.113.0-1 → 0.113.0-11

package/apps/agents-server/src/database/sqlite/localSqliteSupabase/ensureTable.ts

@@ -0,0 +1,93 @@
+import type { AgentsServerSqliteDatabase } from '../$provideAgentsServerSqliteDatabase';
+import { quoteIdentifier, sanitizeSqlIdentifier, uniqueStrings } from './localSqliteSql';
+import {
+    isTextPrimaryKeyTable,
+    resolveReadIndexColumns,
+    resolveReadIndexes,
+    resolveSqliteColumnType,
+    resolveTableBaseName,
+    resolveUniqueIndexColumns,
+    resolveUniqueIndexes,
+} from './localSqliteTableSchema';
+
+/**
+ * Ensures a table and all required columns exist.
+ *
+ * @private function of `$provideLocalSqliteSupabase`
+ */
+export function ensureTable(
+    database: AgentsServerSqliteDatabase,
+    tableName: string,
+    requiredColumns: ReadonlyArray<string>,
+): void {
+    const tableBaseName = resolveTableBaseName(tableName);
+    const primaryKey = isTextPrimaryKeyTable(tableBaseName)
+        ? '"id" TEXT PRIMARY KEY'
+        : '"id" INTEGER PRIMARY KEY AUTOINCREMENT';
+
+    database.exec(`CREATE TABLE IF NOT EXISTS ${quoteIdentifier(tableName)} (${primaryKey})`);
+
+    const existingColumns = new Set(
+        database
+            .prepare(`PRAGMA table_info(${quoteIdentifier(tableName)})`)
+            .all()
+            .map((row) => String(row.name)),
+    );
+    const columnsToEnsure = uniqueStrings([...requiredColumns, ...resolveUniqueIndexColumns(tableBaseName)]).filter(
+        (column) => column !== '*' && column !== 'id',
+    );
+    const columnsToEnsureWithIndexes = uniqueStrings([...columnsToEnsure, ...resolveReadIndexColumns(tableBaseName)]);
+
+    for (const column of columnsToEnsureWithIndexes) {
+        if (existingColumns.has(column)) {
+            continue;
+        }
+
+        database.exec(
+            `ALTER TABLE ${quoteIdentifier(tableName)} ADD COLUMN ${quoteIdentifier(column)} ${resolveSqliteColumnType(
+                tableBaseName,
+                column,
+            )}`,
+        );
+        existingColumns.add(column);
+    }
+
+    ensureUniqueIndexes(database, tableName, tableBaseName);
+    ensureReadIndexes(database, tableName, tableBaseName);
+}
+
+/**
+ * Creates known unique indexes after required columns exist.
+ *
+ * @private function of `ensureTable`
+ */
+function ensureUniqueIndexes(database: AgentsServerSqliteDatabase, tableName: string, tableBaseName: string): void {
+    const uniqueIndexes = resolveUniqueIndexes(tableBaseName);
+
+    for (const columns of uniqueIndexes) {
+        const indexName = `idx_${sanitizeSqlIdentifier(tableName)}_${columns.join('_')}_unique`;
+        const columnSql = columns.map(quoteIdentifier).join(', ');
+        database.exec(
+            `CREATE UNIQUE INDEX IF NOT EXISTS ${quoteIdentifier(indexName)} ON ${quoteIdentifier(
+                tableName,
+            )} (${columnSql})`,
+        );
+    }
+}
+
+/**
+ * Creates known read indexes after required columns exist.
+ *
+ * @private function of `ensureTable`
+ */
+function ensureReadIndexes(database: AgentsServerSqliteDatabase, tableName: string, tableBaseName: string): void {
+    const readIndexes = resolveReadIndexes(tableBaseName);
+
+    for (const readIndex of readIndexes) {
+        const indexName = `index_${sanitizeSqlIdentifier(tableName)}_${sanitizeSqlIdentifier(readIndex.name)}`;
+        const columnSql = readIndex.columns.map(quoteIdentifier).join(', ');
+        database.exec(
+            `CREATE INDEX IF NOT EXISTS ${quoteIdentifier(indexName)} ON ${quoteIdentifier(tableName)} (${columnSql})`,
+        );
+    }
+}

package/apps/agents-server/src/database/sqlite/localSqliteSupabase/localSqliteFilters.ts

@@ -0,0 +1,202 @@
+import type { LocalSqliteFilter, LocalSqliteSqlFragment } from './localSqliteTypes';
+import { quoteIdentifier } from './localSqliteSql';
+import { serializeValue } from './localSqliteValueCodec';
+
+/**
+ * Parsed PostgREST filter expression.
+ *
+ * @private type of `$provideLocalSqliteSupabase`
+ */
+export type ParsedPostgrestFilter = {
+    readonly column: string;
+    readonly operator: string;
+    readonly value: string;
+};
+
+/**
+ * Creates SQL for one simple filter.
+ *
+ * @private function of `$provideLocalSqliteSupabase`
+ */
+export function createFilterCondition(tableName: string, filter: LocalSqliteFilter): LocalSqliteSqlFragment {
+    const column = quoteIdentifier(filter.column);
+    const value = serializeValue(tableName, filter.column, filter.value);
+
+    switch (filter.operator) {
+        case 'eq':
+            return value === null
+                ? { sql: `${column} IS NULL`, values: [] }
+                : { sql: `${column} = ?`, values: [value] };
+        case 'neq':
+            return value === null
+                ? { sql: `${column} IS NOT NULL`, values: [] }
+                : { sql: `${column} <> ?`, values: [value] };
+        case 'is':
+            return filter.value === null
+                ? { sql: `${column} IS NULL`, values: [] }
+                : { sql: `${column} IS ?`, values: [value] };
+        case 'not-is':
+            return filter.value === null
+                ? { sql: `${column} IS NOT NULL`, values: [] }
+                : { sql: `${column} IS NOT ?`, values: [value] };
+        case 'in': {
+            const values = Array.isArray(filter.value)
+                ? filter.value.map((item) => serializeValue(tableName, filter.column, item))
+                : [];
+            if (values.length === 0) {
+                return { sql: '0 = 1', values: [] };
+            }
+            return { sql: `${column} IN (${values.map(() => '?').join(', ')})`, values };
+        }
+        case 'lt':
+            return { sql: `${column} < ?`, values: [value] };
+        case 'lte':
+            return { sql: `${column} <= ?`, values: [value] };
+        case 'gt':
+            return { sql: `${column} > ?`, values: [value] };
+        case 'gte':
+            return { sql: `${column} >= ?`, values: [value] };
+        case 'like':
+            return { sql: `${column} LIKE ? ESCAPE '\\'`, values: [value] };
+        case 'ilike':
+            return { sql: `LOWER(${column}) LIKE LOWER(?) ESCAPE '\\'`, values: [value] };
+        default:
+            return { sql: '1 = 1', values: [] };
+    }
+}
+
+/**
+ * Creates SQL for one PostgREST `.or(...)` filter.
+ *
+ * @private function of `$provideLocalSqliteSupabase`
+ */
+export function createOrFilterCondition(tableName: string, filter: string): LocalSqliteSqlFragment | null {
+    const conditions: Array<string> = [];
+    const values: Array<unknown> = [];
+
+    for (const part of splitPostgrestOrFilter(filter)) {
+        const parsedFilter = parsePostgrestFilter(part);
+        if (!parsedFilter) {
+            continue;
+        }
+
+        if (parsedFilter.operator === 'cs') {
+            conditions.push('0 = 1');
+            continue;
+        }
+
+        const condition = createFilterCondition(tableName, {
+            column: parsedFilter.column,
+            operator: normalizePostgrestOperator(parsedFilter.operator),
+            value: decodePostgrestFilterValue(parsedFilter.value),
+        });
+        conditions.push(condition.sql);
+        values.push(...condition.values);
+    }
+
+    if (conditions.length === 0) {
+        return null;
+    }
+
+    return {
+        sql: `(${conditions.join(' OR ')})`,
+        values,
+    };
+}
+
+/**
+ * Splits a PostgREST OR filter while keeping JSON literals intact.
+ *
+ * @private function of `$provideLocalSqliteSupabase`
+ */
+export function splitPostgrestOrFilter(filter: string): Array<string> {
+    const parts: Array<string> = [];
+    let current = '';
+    let depth = 0;
+    let isInsideString = false;
+
+    for (let index = 0; index < filter.length; index++) {
+        const character = filter[index]!;
+        const previousCharacter = filter[index - 1];
+
+        if (character === '"' && previousCharacter !== '\\') {
+            isInsideString = !isInsideString;
+        } else if (!isInsideString && (character === '{' || character === '[')) {
+            depth++;
+        } else if (!isInsideString && (character === '}' || character === ']')) {
+            depth--;
+        }
+
+        if (character === ',' && depth === 0 && !isInsideString) {
+            parts.push(current);
+            current = '';
+            continue;
+        }
+
+        current += character;
+    }
+
+    if (current) {
+        parts.push(current);
+    }
+
+    return parts.map((part) => part.trim()).filter(Boolean);
+}
+
+/**
+ * Parses one PostgREST filter expression.
+ *
+ * @private function of `$provideLocalSqliteSupabase`
+ */
+export function parsePostgrestFilter(filter: string): ParsedPostgrestFilter | null {
+    const match = /^([^.]*)\.([a-z]+)\.([\s\S]*)$/iu.exec(filter.trim());
+    if (!match) {
+        return null;
+    }
+
+    return {
+        column: match[1]!,
+        operator: match[2]!.toLowerCase(),
+        value: match[3]!,
+    };
+}
+
+/**
+ * Converts PostgREST operators into internal filter operators.
+ *
+ * @private function of `createOrFilterCondition`
+ */
+function normalizePostgrestOperator(operator: string): LocalSqliteFilter['operator'] {
+    switch (operator) {
+        case 'neq':
+            return 'neq';
+        case 'ilike':
+            return 'ilike';
+        case 'like':
+            return 'like';
+        case 'lt':
+            return 'lt';
+        case 'lte':
+            return 'lte';
+        case 'gt':
+            return 'gt';
+        case 'gte':
+            return 'gte';
+        case 'eq':
+        default:
+            return 'eq';
+    }
+}
+
+/**
+ * Decodes a PostgREST filter value when URL-encoded by callers.
+ *
+ * @private function of `createOrFilterCondition`
+ */
+function decodePostgrestFilterValue(value: string): string {
+    try {
+        return decodeURIComponent(value);
+    } catch {
+        return value;
+    }
+}

package/apps/agents-server/src/database/sqlite/localSqliteSupabase/localSqliteMutationPayload.ts

@@ -0,0 +1,131 @@
+import type { TODO_any } from '@promptbook-local/types';
+
+/**
+ * Converts mutation payloads into a uniform array of records.
+ *
+ * @private function of `$provideLocalSqliteSupabase`
+ */
+export function normalizeMutationRows(values: TODO_any): Array<Record<string, unknown>> {
+    if (Array.isArray(values)) {
+        return values.map((row) => stripUndefinedValues(row || {}));
+    }
+
+    return [stripUndefinedValues(values || {})];
+}
+
+/**
+ * Removes undefined values because Supabase omits them from mutation payloads.
+ *
+ * @private function of `$provideLocalSqliteSupabase`
+ */
+export function stripUndefinedValues(values: Record<string, unknown>): Record<string, unknown> {
+    const result: Record<string, unknown> = {};
+
+    for (const [key, value] of Object.entries(values)) {
+        if (value !== undefined) {
+            result[key] = value;
+        }
+    }
+
+    return result;
+}
+
+/**
+ * Adds SQLite-side defaults that are normally supplied by PostgreSQL migrations.
+ *
+ * @private function of `$provideLocalSqliteSupabase`
+ */
+export function withInsertDefaults(tableBaseName: string, row: Record<string, unknown>): Record<string, unknown> {
+    const nowIso = new Date().toISOString();
+    const result = { ...row };
+
+    if (result.createdAt === undefined) {
+        result.createdAt = nowIso;
+    }
+    if (result.updatedAt === undefined && tableBaseName !== 'AgentHistory' && tableBaseName !== 'ChatHistory') {
+        result.updatedAt = nowIso;
+    }
+
+    switch (tableBaseName) {
+        case 'Agent':
+            result.visibility ??= 'PRIVATE';
+            result.folderId ??= null;
+            result.sortOrder ??= Date.now();
+            result.deletedAt ??= null;
+            result.preparedModelRequirements ??= null;
+            break;
+        case 'AgentFolder':
+            result.parentId ??= null;
+            result.sortOrder ??= Date.now();
+            result.deletedAt ??= null;
+            result.icon ??= null;
+            result.color ??= null;
+            break;
+        case 'User':
+            result.isAdmin ??= false;
+            result.profileImageUrl ??= null;
+            result.email ??= null;
+            result.displayName ??= null;
+            result.authenticationProvider ??= 'LOCAL';
+            break;
+        case 'ShibbolethUserIdentity':
+            result.displayName ??= null;
+            result.nameId ??= null;
+            result.nameIdFormat ??= null;
+            result.unstructuredName ??= null;
+            result.eduPersonPrincipalName ??= null;
+            result.rawAttributes ??= null;
+            result.lastLoggedInAt ??= null;
+            result.loginCount ??= 0;
+            break;
+        case 'ShibbolethAuthenticationAttempt':
+            result.userId ??= null;
+            result.email ??= null;
+            result.displayName ??= null;
+            result.nameId ??= null;
+            result.relayState ??= null;
+            result.ip ??= null;
+            result.userAgent ??= null;
+            result.errorMessage ??= null;
+            result.rawAttributes ??= null;
+            break;
+        case 'UserChat':
+            result.messages ??= [];
+            result.source ??= 'WEB_UI';
+            result.title ??= null;
+            result.draftMessage ??= null;
+            break;
+        case 'UserChatJob':
+            result.parameters ??= {};
+            result.queuedAt ??= nowIso;
+            result.attemptCount ??= 0;
+            break;
+        case 'UserChatTimeout':
+            result.parameters ??= {};
+            result.queuedAt ??= nowIso;
+            result.attemptCount ??= 0;
+            result.runCount ??= 0;
+            break;
+        case 'ApiTokens':
+            result.isRevoked ??= false;
+            break;
+        case 'Wallet':
+            result.isUserScoped ??= true;
+            result.isGlobal ??= false;
+            result.deletedAt ??= null;
+            break;
+        case 'UserMemory':
+            result.isGlobal ??= false;
+            result.deletedAt ??= null;
+            break;
+        case 'ShareTargetPayload':
+            result.attachments ??= [];
+            result.consumedAt ??= null;
+            break;
+        case 'UserPushSubscription':
+            result.isChatFocused ??= false;
+            break;
+    }
+
+    return result;
+}

package/apps/agents-server/src/database/sqlite/localSqliteSupabase/localSqliteRowOperations.ts

@@ -0,0 +1,102 @@
+import type { AgentsServerSqliteDatabase } from '../$provideAgentsServerSqliteDatabase';
+import { createSelectExpression, quoteIdentifier } from './localSqliteSql';
+import { deserializeRow, serializeValue } from './localSqliteValueCodec';
+import { ensureTable } from './ensureTable';
+
+/**
+ * Inserts one row into the table.
+ *
+ * @private function of `$provideLocalSqliteSupabase`
+ */
+export function insertRow(
+    database: AgentsServerSqliteDatabase,
+    tableName: string,
+    row: Record<string, unknown>,
+): { readonly lastInsertRowid: number | bigint } {
+    const columns = Object.keys(row).filter((column) => row[column] !== undefined);
+
+    if (columns.length === 0) {
+        return database.prepare(`INSERT INTO ${quoteIdentifier(tableName)} DEFAULT VALUES`).run();
+    }
+
+    const placeholders = columns.map(() => '?').join(', ');
+    const values = columns.map((column) => serializeValue(tableName, column, row[column]));
+    const sql = `INSERT INTO ${quoteIdentifier(tableName)} (${columns
+        .map(quoteIdentifier)
+        .join(', ')}) VALUES (${placeholders})`;
+
+    return database.prepare(sql).run(...values);
+}
+
+/**
+ * Updates one row by SQLite rowid.
+ *
+ * @private function of `$provideLocalSqliteSupabase`
+ */
+export function updateRowid(
+    database: AgentsServerSqliteDatabase,
+    tableName: string,
+    rowid: number | bigint,
+    row: Record<string, unknown>,
+): void {
+    const columns = Object.keys(row).filter((column) => column !== 'id' && row[column] !== undefined);
+    if (columns.length === 0) {
+        return;
+    }
+
+    const assignments = columns.map((column) => `${quoteIdentifier(column)} = ?`).join(', ');
+    const values = columns.map((column) => serializeValue(tableName, column, row[column]));
+    database.prepare(`UPDATE ${quoteIdentifier(tableName)} SET ${assignments} WHERE rowid = ?`).run(...values, rowid);
+}
+
+/**
+ * Finds the rowid matching an upsert conflict target.
+ *
+ * @private function of `$provideLocalSqliteSupabase`
+ */
+export function findConflictRowid(
+    database: AgentsServerSqliteDatabase,
+    tableName: string,
+    row: Record<string, unknown>,
+    conflictColumns: ReadonlyArray<string>,
+): number | bigint | null {
+    if (conflictColumns.some((column) => row[column] === undefined)) {
+        return null;
+    }
+
+    const conditions = conflictColumns.map((column) => `${quoteIdentifier(column)} = ?`).join(' AND ');
+    const values = conflictColumns.map((column) => serializeValue(tableName, column, row[column]));
+    const result = database
+        .prepare(`SELECT rowid FROM ${quoteIdentifier(tableName)} WHERE ${conditions} LIMIT 1`)
+        .get(...values);
+
+    return result ? (result.rowid as number | bigint) : null;
+}
+
+/**
+ * Selects rows by rowids for a mutation returning clause.
+ *
+ * @private function of `$provideLocalSqliteSupabase`
+ */
+export function selectRowsByRowids(
+    database: AgentsServerSqliteDatabase,
+    tableName: string,
+    rowids: ReadonlyArray<number | bigint>,
+    selectedColumns: ReadonlyArray<string>,
+): Array<Record<string, unknown>> {
+    if (rowids.length === 0) {
+        return [];
+    }
+
+    ensureTable(database, tableName, selectedColumns);
+    const placeholders = rowids.map(() => '?').join(', ');
+    const rows = database
+        .prepare(
+            `SELECT ${createSelectExpression(selectedColumns)} FROM ${quoteIdentifier(
+                tableName,
+            )} WHERE rowid IN (${placeholders})`,
+        )
+        .all(...rowids);
+
+    return rows.map((row) => deserializeRow(tableName, row));
+}

package/apps/agents-server/src/database/sqlite/localSqliteSupabase/localSqliteSql.ts

@@ -0,0 +1,59 @@
+/**
+ * Quotes one SQLite identifier.
+ *
+ * @private function of `$provideLocalSqliteSupabase`
+ */
+export function quoteIdentifier(identifier: string): string {
+    return `"${identifier.replace(/"/g, '""')}"`;
+}
+
+/**
+ * Creates a safe identifier suffix for generated index names.
+ *
+ * @private function of `$provideLocalSqliteSupabase`
+ */
+export function sanitizeSqlIdentifier(identifier: string): string {
+    return identifier.replace(/[^A-Za-z0-9_]/g, '_');
+}
+
+/**
+ * Creates a select expression from parsed columns.
+ *
+ * @private function of `$provideLocalSqliteSupabase`
+ */
+export function createSelectExpression(columns: ReadonlyArray<string>): string {
+    if (columns.length === 0 || columns.includes('*')) {
+        return '*';
+    }
+
+    return columns.map(quoteIdentifier).join(', ');
+}
+
+/**
+ * Parses a simple Supabase select column list.
+ *
+ * @private function of `$provideLocalSqliteSupabase`
+ */
+export function parseSelectedColumns(columns: string): Array<string> {
+    const trimmedColumns = columns.trim();
+    if (!trimmedColumns || trimmedColumns === '*') {
+        return ['*'];
+    }
+
+    return trimmedColumns
+        .split(',')
+        .map((column) => column.trim())
+        .filter(Boolean)
+        .map((column) => column.split(':').pop() || column)
+        .map((column) => column.replace(/\s+/g, ''))
+        .filter((column) => /^[A-Za-z_][A-Za-z0-9_]*$/u.test(column));
+}
+
+/**
+ * Deduplicates strings while preserving order.
+ *
+ * @private function of `$provideLocalSqliteSupabase`
+ */
+export function uniqueStrings(values: ReadonlyArray<string>): Array<string> {
+    return Array.from(new Set(values.filter(Boolean)));
+}