@syncular/server 0.0.6-96 → 0.1.1

package/dist/handlers/create-handler.js

@@ -1,17 +1,12 @@
 /**
  * @syncular/server - Declarative server handler helper
  */
-import { applyCodecsFromDbRow, applyCodecsToDbRow, extractScopeVars, normalizeScopes, toTableColumnCodecs, } from '@syncular/core';
+import { applyCodecsFromDbRow, applyCodecsToDbRow, createSingleVariableScopeMetadata, createTableColumnCodecsResolver, toTableColumnCodecs, } from '@syncular/core';
 import { sql } from 'kysely';
-function classifyConstraintViolationCode(message) {
-    const normalized = message.toLowerCase();
-    if (normalized.includes('not null'))
-        return 'NOT_NULL_CONSTRAINT';
-    if (normalized.includes('unique'))
-        return 'UNIQUE_CONSTRAINT';
-    if (normalized.includes('foreign key'))
-        return 'FOREIGN_KEY_CONSTRAINT';
-    return 'CONSTRAINT_VIOLATION';
+import { coerceNumber } from '../dialect/helpers.js';
+import { rowScopesAllowed } from '../helpers/scope-authorization.js';
+function classifyConstraintViolationCode(_message) {
+    return 'sync.constraint_violation';
 }
 function isConstraintViolationError(message) {
     const normalized = message.toLowerCase();
@@ -25,6 +20,28 @@ function isMissingColumnReferenceError(message) {
     return (normalized.includes('no such column') ||
         (normalized.includes('column') && normalized.includes('does not exist')));
 }
+function readSafeVersionColumn(row, versionColumn, defaultValue) {
+    const value = row[versionColumn];
+    if (value === null || value === undefined)
+        return defaultValue;
+    const version = coerceNumber(value);
+    if (version === null || !Number.isSafeInteger(version)) {
+        throw new Error(`Version column "${versionColumn}" must be a safe integer`);
+    }
+    return version;
+}
+function normalizeOutboundVersionColumn(row, versionColumn, version) {
+    if (row === null || typeof row !== 'object' || Array.isArray(row)) {
+        return row;
+    }
+    if (!Object.hasOwn(row, versionColumn)) {
+        return row;
+    }
+    return {
+        ...row,
+        [versionColumn]: version,
+    };
+}
 /**
  * Create a declarative server table handler with sensible defaults.
  *
@@ -53,40 +70,17 @@ function isMissingColumnReferenceError(message) {
  * ```
  */
 export function createServerHandler(options) {
-    const { table, scopes: scopeDefs, primaryKey = 'id', versionColumn = 'server_version', dependsOn, snapshotChunkTtlMs, resolveScopes, transformInbound, transformOutbound, codecs, codecDialect = 'sqlite', authorize, extractScopes: customExtractScopes, } = options;
-    const codecCache = new Map();
-    const resolveTableCodecs = (row) => {
-        if (!codecs)
-            return {};
-        const columns = Object.keys(row);
-        if (columns.length === 0)
-            return {};
-        const cacheKey = columns.slice().sort().join('\u0000');
-        const cached = codecCache.get(cacheKey);
-        if (cached)
-            return cached;
-        const resolved = toTableColumnCodecs(table, codecs, columns, {
-            dialect: codecDialect,
-        });
-        codecCache.set(cacheKey, resolved);
-        return resolved;
-    };
-    // Normalize scopes to pattern map and extract patterns/columns
-    const scopeColumnMap = normalizeScopes(scopeDefs);
-    const scopePatterns = Object.keys(scopeColumnMap);
-    const scopeColumns = {};
-    for (const [pattern, columnName] of Object.entries(scopeColumnMap)) {
-        const vars = extractScopeVars(pattern);
-        if (vars.length !== 1) {
-            throw new Error(`Scope pattern "${pattern}" must contain exactly one placeholder (got ${vars.length}).`);
-        }
-        const varName = vars[0];
-        const existing = scopeColumns[varName];
-        if (existing && existing !== columnName) {
-            throw new Error(`Scope variable "${varName}" is mapped to multiple columns: "${existing}" and "${columnName}".`);
-        }
-        scopeColumns[varName] = columnName;
-    }
+    const { table, scopes: scopeDefs, primaryKey = 'id', versionColumn = 'server_version', dependsOn, snapshotChunkTtlMs, snapshotBinaryColumns, snapshotBinaryColumnsForVersion, snapshotBinaryEncoder, snapshotBinaryEncoderForVersion, resolveScopes, transformInbound, transformOutbound, codecs, codecDialect = 'sqlite', authorize, extractScopes: customExtractScopes, } = options;
+    const resolveRowCodecs = createTableColumnCodecsResolver(codecs, {
+        dialect: codecDialect,
+    });
+    const primaryKeyColumn = primaryKey;
+    const qualifiedVersionRef = `${table}.${versionColumn}`;
+    const resolveTableCodecs = (row) => resolveRowCodecs(table, row);
+    const usePassthroughInbound = !transformInbound && codecs == null;
+    const { scopePatterns, scopeColumnsByVariable: scopeColumns } = createSingleVariableScopeMetadata(scopeDefs);
+    const scopeColumnEntries = Object.entries(scopeColumns);
+    const requiredScopeKeys = Object.keys(scopeColumns);
     // Default extractScopes from scope columns
     const defaultExtractScopes = (row) => {
         const scopes = {};
@@ -106,12 +100,77 @@ export function createServerHandler(options) {
         const resolved = await resolveScopes(ctx);
         const normalized = {};
         for (const [scopeKey, scopeValue] of Object.entries(resolved)) {
-            if (typeof scopeValue === 'string' || Array.isArray(scopeValue)) {
+            // null/undefined means "no access for this scope" and is skipped.
+            if (scopeValue === null || scopeValue === undefined)
+                continue;
+            if (typeof scopeValue === 'string') {
                 normalized[scopeKey] = scopeValue;
+                continue;
+            }
+            if (Array.isArray(scopeValue)) {
+                const invalidIndex = scopeValue.findIndex((entry) => typeof entry !== 'string');
+                if (invalidIndex !== -1) {
+                    throw new Error(`resolveScopes() for table "${table}" returned a non-string entry ` +
+                        `(${typeof scopeValue[invalidIndex]}) at index ${invalidIndex} of scope "${scopeKey}". ` +
+                        'Scope values must be strings or string arrays.');
+                }
+                normalized[scopeKey] = scopeValue;
+                continue;
             }
+            throw new Error(`resolveScopes() for table "${table}" returned an invalid value ` +
+                `(${typeof scopeValue}) for scope "${scopeKey}". ` +
+                'Scope values must be strings or string arrays.');
         }
         return normalized;
     };
+    const writeScopeCache = new WeakMap();
+    const resolveWriteScopes = (ctx) => {
+        const cached = writeScopeCache.get(ctx);
+        if (cached)
+            return cached;
+        const loaded = resolveScopesImpl(ctx);
+        writeScopeCache.set(ctx, loaded);
+        return loaded;
+    };
+    const authorizeRowScopes = async (ctx, row) => {
+        if (requiredScopeKeys.length === 0)
+            return true;
+        let allowedScopes;
+        try {
+            allowedScopes = await resolveWriteScopes(ctx);
+        }
+        catch (resolveErr) {
+            console.error(`[resolveScopes] Failed for table ${table} during write authorization:`, resolveErr);
+            return {
+                error: 'Forbidden',
+                code: 'sync.forbidden',
+                retriable: false,
+            };
+        }
+        const rowScopes = extractScopesImpl(row);
+        if (rowScopesAllowed({
+            rowScopes,
+            allowedScopes,
+            requiredScopeKeys,
+        })) {
+            return true;
+        }
+        return {
+            error: 'Forbidden',
+            code: 'sync.forbidden',
+            retriable: false,
+        };
+    };
+    const rejectionResult = (opIndex, rejection) => ({
+        result: {
+            opIndex,
+            status: 'error',
+            error: rejection.error,
+            code: rejection.code,
+            retriable: rejection.retriable ?? false,
+        },
+        emittedChanges: [],
+    });
     const applyOutboundTransform = (row) => {
         if (transformOutbound) {
             return transformOutbound(row);
@@ -121,6 +180,9 @@ export function createServerHandler(options) {
         return transformed;
     };
     const applyInboundTransform = (row, schemaVersion) => {
+        if (usePassthroughInbound) {
+            return row;
+        }
         if (transformInbound) {
             return transformInbound(row, {
                 schemaVersion,
@@ -134,25 +196,21 @@ export function createServerHandler(options) {
         const trx = ctx.db;
         const { ref } = trx.dynamic;
         const scopeValues = ctx.scopeValues;
-        const pageSize = Math.max(1, Math.min(10_000, ctx.limit));
-        // Build dynamic WHERE conditions
-        const whereConditions = [];
-        for (const [varName, columnName] of Object.entries(scopeColumns)) {
+        const pageSize = Math.max(1, ctx.limit);
+        let q = trx.selectFrom(table);
+        q = q.selectAll();
+        for (const [varName, columnName] of scopeColumnEntries) {
             const values = scopeValues[varName];
             if (values === undefined)
                 continue;
             const normalized = Array.isArray(values) ? values : [values];
             if (normalized.length === 0)
                 continue;
-            whereConditions.push({ column: columnName, values: normalized });
-        }
-        let q = trx.selectFrom(table).selectAll();
-        for (const cond of whereConditions) {
-            if (cond.values.length === 1) {
-                q = q.where(ref(cond.column), '=', cond.values[0]);
+            if (normalized.length === 1) {
+                q = q.where(ref(columnName), '=', normalized[0]);
             }
             else {
-                q = q.where(ref(cond.column), 'in', cond.values);
+                q = q.where(ref(columnName), 'in', normalized);
             }
         }
         if (ctx.cursor !== null) {
@@ -168,8 +226,24 @@ export function createServerHandler(options) {
         const nextCursor = hasMore
             ? lastRow?.[primaryKey]
             : null;
-        // Transform outbound if provided
-        const outputRows = pageRows.map((r) => applyOutboundTransform(r));
+        let outputRows;
+        if (transformOutbound) {
+            outputRows = pageRows.map((r) => applyOutboundTransform(r));
+        }
+        else {
+            const firstRow = pageRows[0];
+            const tableCodecs = firstRow
+                ? toTableColumnCodecs(table, codecs, Object.keys(firstRow), {
+                    dialect: codecDialect,
+                })
+                : {};
+            if (Object.keys(tableCodecs).length === 0) {
+                outputRows = pageRows;
+            }
+            else {
+                outputRows = pageRows.map((r) => applyCodecsFromDbRow(r, tableCodecs, codecDialect));
+            }
+        }
         return {
             rows: outputRows,
             nextCursor: typeof nextCursor === 'string' && nextCursor.length > 0
@@ -186,8 +260,8 @@ export function createServerHandler(options) {
                 result: {
                     opIndex,
                     status: 'error',
-                    error: `UNKNOWN_TABLE:${op.table}`,
-                    code: 'UNKNOWN_TABLE',
+                    error: `Unknown table: ${op.table}`,
+                    code: 'sync.unknown_table',
                     retriable: false,
                 },
                 emittedChanges: [],
@@ -211,14 +285,23 @@ export function createServerHandler(options) {
         }
         // Handle delete
         if (op.op === 'delete') {
+            const existingRow = (await trx.selectFrom(table).selectAll()
+                .where(ref(primaryKey), '=', op.row_id)
+                .executeTakeFirst());
+            if (!existingRow) {
+                return { result: { opIndex, status: 'applied' }, emittedChanges: [] };
+            }
+            const scopeAuth = await authorizeRowScopes(ctx, existingRow);
+            if (scopeAuth !== true) {
+                return rejectionResult(opIndex, scopeAuth);
+            }
             const deleted = await trx.deleteFrom(table)
                 .where(ref(primaryKey), '=', op.row_id)
                 .returningAll()
                 .executeTakeFirst();
             const deletedRow = deleted;
-            if (!deletedRow) {
+            if (!deletedRow)
                 return { result: { opIndex, status: 'applied' }, emittedChanges: [] };
-            }
             // Extract scopes from existing row for the delete emission
             const scopes = extractScopesImpl(deletedRow);
             const emitted = {
@@ -240,6 +323,18 @@ export function createServerHandler(options) {
             ? rawPayload
             : {};
         const payload = applyInboundTransform(payloadRecord, ctx.schemaVersion);
+        const rowForInsertScopeCheck = {
+            ...payload,
+            [primaryKey]: op.row_id,
+            [versionColumn]: 1,
+        };
+        const existingRowBeforeWrite = (await trx.selectFrom(table).selectAll()
+            .where(ref(primaryKey), '=', op.row_id)
+            .executeTakeFirst());
+        const rowScopeAuth = await authorizeRowScopes(ctx, existingRowBeforeWrite ?? rowForInsertScopeCheck);
+        if (rowScopeAuth !== true) {
+            return rejectionResult(opIndex, rowScopeAuth);
+        }
         let updated;
         let constraintError = null;
         try {
@@ -260,78 +355,84 @@ export function createServerHandler(options) {
                     .returningAll()
                     .executeTakeFirst());
                 if (!updated) {
-                    const conflictRow = await trx.selectFrom(table).selectAll()
+                    let conflictRow = await trx.selectFrom(table).selectAll()
                         .where(ref(primaryKey), '=', op.row_id)
                         .executeTakeFirst();
-                    if (!conflictRow) {
+                    if (!conflictRow && expectedVersion === 0) {
+                        const insertValues = {
+                            ...payload,
+                            [primaryKey]: op.row_id,
+                            [versionColumn]: 1,
+                        };
+                        try {
+                            updated = (await trx.insertInto(table)
+                                .values(insertValues)
+                                .returningAll()
+                                .executeTakeFirst());
+                        }
+                        catch (err) {
+                            const message = err instanceof Error ? err.message : String(err);
+                            if (!isConstraintViolationError(message)) {
+                                throw err;
+                            }
+                            conflictRow = await trx.selectFrom(table).selectAll()
+                                .where(ref(primaryKey), '=', op.row_id)
+                                .executeTakeFirst();
+                        }
+                    }
+                    if (!updated && !conflictRow) {
                         return {
                             result: {
                                 opIndex,
                                 status: 'error',
-                                error: 'ROW_NOT_FOUND_FOR_BASE_VERSION',
-                                code: 'ROW_MISSING',
+                                error: 'Row not found for base version',
+                                code: 'sync.row_missing',
                                 retriable: false,
                             },
                             emittedChanges: [],
                         };
                     }
-                    const existingVersion = conflictRow[versionColumn] ?? 0;
-                    return {
-                        result: {
-                            opIndex,
-                            status: 'conflict',
-                            message: `Version conflict: server=${existingVersion}, base=${expectedVersion}`,
-                            server_version: existingVersion,
-                            server_row: applyOutboundTransform(conflictRow),
-                        },
-                        emittedChanges: [],
-                    };
+                    if (!updated && conflictRow) {
+                        const conflictScopeAuth = await authorizeRowScopes(ctx, conflictRow);
+                        if (conflictScopeAuth !== true) {
+                            return rejectionResult(opIndex, conflictScopeAuth);
+                        }
+                        const existingVersion = readSafeVersionColumn(conflictRow, versionColumn, 0);
+                        return {
+                            result: {
+                                opIndex,
+                                status: 'conflict',
+                                message: `Version conflict: server=${existingVersion}, base=${expectedVersion}`,
+                                code: 'sync.version_conflict',
+                                server_version: existingVersion,
+                                server_row: normalizeOutboundVersionColumn(applyOutboundTransform(conflictRow), versionColumn, existingVersion),
+                            },
+                            emittedChanges: [],
+                        };
+                    }
                 }
             }
             else {
                 const updateSet = {
                     ...payload,
-                    [versionColumn]: sql `${sql.ref(versionColumn)} + 1`,
+                    [versionColumn]: sql `${sql.ref(qualifiedVersionRef)} + 1`,
                 };
                 delete updateSet[primaryKey];
                 for (const col of Object.values(scopeColumns)) {
                     delete updateSet[col];
                 }
-                updated = (await trx.updateTable(table)
-                    .set(updateSet)
-                    .where(ref(primaryKey), '=', op.row_id)
+                const insertValues = {
+                    ...payload,
+                    [primaryKey]: op.row_id,
+                    [versionColumn]: 1,
+                };
+                updated = (await trx.insertInto(table)
+                    .values(insertValues)
+                    .onConflict((oc) => oc
+                    .column(primaryKeyColumn)
+                    .doUpdateSet(updateSet))
                     .returningAll()
                     .executeTakeFirst());
-                if (!updated) {
-                    const insertValues = {
-                        ...payload,
-                        [primaryKey]: op.row_id,
-                        [versionColumn]: 1,
-                    };
-                    try {
-                        updated = (await trx.insertInto(table)
-                            .values(insertValues)
-                            .returningAll()
-                            .executeTakeFirst());
-                    }
-                    catch (err) {
-                        const message = err instanceof Error ? err.message : String(err);
-                        if (!isConstraintViolationError(message)) {
-                            throw err;
-                        }
-                        updated = (await trx.updateTable(table)
-                            .set(updateSet)
-                            .where(ref(primaryKey), '=', op.row_id)
-                            .returningAll()
-                            .executeTakeFirst());
-                        if (!updated) {
-                            constraintError = {
-                                message,
-                                code: classifyConstraintViolationCode(message),
-                            };
-                        }
-                    }
-                }
             }
         }
         catch (err) {
@@ -345,8 +446,8 @@ export function createServerHandler(options) {
                         result: {
                             opIndex,
                             status: 'error',
-                            error: 'ROW_NOT_FOUND_FOR_BASE_VERSION',
-                            code: 'ROW_MISSING',
+                            error: 'Row not found for base version',
+                            code: 'sync.row_missing',
                             retriable: false,
                         },
                         emittedChanges: [],
@@ -377,11 +478,11 @@ export function createServerHandler(options) {
             throw new Error('Updated row is missing after applyOperation');
         }
         const updatedRow = updated;
-        const rowVersion = updatedRow[versionColumn] ?? 1;
+        const rowVersion = readSafeVersionColumn(updatedRow, versionColumn, 1);
         // Extract scopes from updated row
         const scopes = extractScopesImpl(updatedRow);
         // Transform outbound for emitted change
-        const rowJson = applyOutboundTransform(updated);
+        const rowJson = normalizeOutboundVersionColumn(applyOutboundTransform(updated), versionColumn, rowVersion);
         const emitted = {
             table,
             row_id: op.row_id,
@@ -395,15 +496,131 @@ export function createServerHandler(options) {
             emittedChanges: [emitted],
         };
     };
+    const defaultApplyOperationBatch = async (ctx, operations) => {
+        if (operations.length === 0)
+            return [];
+        const runSequentialFallback = async () => {
+            const sequential = [];
+            for (const entry of operations) {
+                const applied = await defaultApplyOperation(ctx, entry.op, entry.opIndex);
+                sequential.push(applied);
+                if (applied.result.status !== 'applied') {
+                    break;
+                }
+            }
+            return sequential;
+        };
+        if (operations.length === 1 || authorize || requiredScopeKeys.length > 0) {
+            return runSequentialFallback();
+        }
+        const trx = ctx.trx;
+        const prepared = [];
+        const seenRowIds = new Set();
+        const payloadKeySignatures = new Set();
+        for (const entry of operations) {
+            const op = entry.op;
+            if (op.table !== table || op.op !== 'upsert' || op.base_version != null) {
+                return runSequentialFallback();
+            }
+            if (seenRowIds.has(op.row_id)) {
+                return runSequentialFallback();
+            }
+            seenRowIds.add(op.row_id);
+            const rawPayload = op.payload ?? {};
+            const payloadRecord = rawPayload !== null && typeof rawPayload === 'object'
+                ? rawPayload
+                : {};
+            const payload = applyInboundTransform(payloadRecord, ctx.schemaVersion);
+            payloadKeySignatures.add(Object.keys(payload).sort().join('\u0000'));
+            const insertValues = {
+                ...payload,
+                [primaryKey]: op.row_id,
+                [versionColumn]: 1,
+            };
+            prepared.push({
+                entry,
+                payload,
+                insertValues,
+            });
+        }
+        if (prepared.length <= 1 || payloadKeySignatures.size !== 1) {
+            return runSequentialFallback();
+        }
+        const basePayload = prepared[0].payload;
+        const updateSet = {
+            ...basePayload,
+            [versionColumn]: sql `${sql.ref(qualifiedVersionRef)} + 1`,
+        };
+        delete updateSet[primaryKey];
+        for (const col of Object.values(scopeColumns)) {
+            delete updateSet[col];
+        }
+        try {
+            const updatedRows = (await trx.insertInto(table)
+                .values(prepared.map((item) => item.insertValues))
+                .onConflict((oc) => oc.column(primaryKeyColumn).doUpdateSet(updateSet))
+                .returningAll()
+                .execute());
+            const updatedById = new Map();
+            for (const row of updatedRows) {
+                const rowIdValue = row[primaryKey];
+                if (rowIdValue === null || rowIdValue === undefined)
+                    continue;
+                updatedById.set(String(rowIdValue), row);
+            }
+            const results = [];
+            for (const item of prepared) {
+                const rowId = item.entry.op.row_id;
+                const updated = updatedById.get(rowId);
+                if (!updated) {
+                    return runSequentialFallback();
+                }
+                const rowVersion = readSafeVersionColumn(updated, versionColumn, 1);
+                const scopes = extractScopesImpl(updated);
+                const rowJson = normalizeOutboundVersionColumn(applyOutboundTransform(updated), versionColumn, rowVersion);
+                results.push({
+                    result: { opIndex: item.entry.opIndex, status: 'applied' },
+                    emittedChanges: [
+                        {
+                            table,
+                            row_id: rowId,
+                            op: 'upsert',
+                            row_json: rowJson,
+                            row_version: rowVersion,
+                            scopes,
+                        },
+                    ],
+                });
+            }
+            return results;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            if (isConstraintViolationError(message)) {
+                return runSequentialFallback();
+            }
+            throw err;
+        }
+    };
     return {
         table,
+        primaryKeyColumn,
         scopePatterns,
         dependsOn,
         snapshotChunkTtlMs,
+        snapshotBinaryColumns,
+        snapshotBinaryColumnsForVersion,
+        snapshotBinaryEncoder: snapshotBinaryEncoder,
+        snapshotBinaryEncoderForVersion: snapshotBinaryEncoderForVersion,
+        canRejectSingleOperationWithoutSavepoint: options.canRejectSingleOperationWithoutSavepoint ??
+            options.applyOperation === undefined,
         resolveScopes: resolveScopesImpl,
         extractScopes: extractScopesImpl,
         snapshot: options.snapshot ?? defaultSnapshot,
         applyOperation: options.applyOperation ?? defaultApplyOperation,
+        applyOperationBatch: options.applyOperation === undefined
+            ? defaultApplyOperationBatch
+            : undefined,
     };
 }
 //# sourceMappingURL=create-handler.js.map