@fadhilp/stateql 0.5.3 → 0.6.0

package/dist/src/response-data.js

@@ -1,3 +1,4 @@
+import { parseJson } from "./util.js";
 export function sessionData(session) {
     return {
         session_id: session.id,
@@ -27,8 +28,19 @@ export function operationData(operation) {
         state_version_before: operation.state_version_before,
         state_version_after: operation.state_version_after,
         ...(operation.replay_of ? { replay_of: operation.replay_of } : {}),
+        ...(operation.outcome_json === null
+            ? {}
+            : {
+                outcome: parseJson(operation.outcome_json, `operation "${operation.id}" outcome`, isMongoWriteOutcome),
+            }),
     };
 }
+function isMongoWriteOutcome(value) {
+    return Boolean(value) &&
+        typeof value === "object" &&
+        !Array.isArray(value) &&
+        typeof value.acknowledged === "boolean";
+}
 export function transactionData(transaction, statements) {
     return {
         transaction_id: transaction.id,

package/dist/src/sql.d.ts

@@ -1,5 +1,5 @@
 import type { AST } from "node-sql-parser";
-import type { Driver } from "./types.js";
+import type { Driver, SqlDriver } from "./types.js";
 export type StatementType = "select" | "insert" | "replace" | "update" | "delete" | "create" | "alter" | "drop" | "truncate";
 export interface SqlAnalysis {
     ast: AST;
@@ -10,4 +10,6 @@ export interface SqlAnalysis {
     destructive: boolean;
     ordered: boolean;
 }
+export declare function analyzeSql(sql: string, driver: SqlDriver): SqlAnalysis;
+/** @internal Compatibility for existing connection records during Mongo rollout. */
 export declare function analyzeSql(sql: string, driver: Driver): SqlAnalysis;

package/dist/src/sql.js

@@ -14,6 +14,9 @@ const SUPPORTED_STATEMENTS = new Set([
     "truncate",
 ]);
 export function analyzeSql(sql, driver) {
+    if (driver === "mongodb") {
+        throw new StateQLError("INVALID_SQL", "SQL is not supported for MongoDB connections.");
+    }
     const trimmed = sql.trim();
     if (!trimmed)
         throw new StateQLError("INVALID_SQL", "SQL is empty.");
@@ -23,7 +26,10 @@ export function analyzeSql(sql, driver) {
             : driver === "mysql"
                 ? "MySQL"
                 : "Sqlite";
-        const parsed = parser.astify(trimmed, { database });
+        const parserSql = driver === "postgres"
+            ? postgresParserSql(trimmed)
+            : trimmed;
+        const parsed = parser.astify(parserSql, { database });
         if (Array.isArray(parsed)) {
             if (parsed.length !== 1) {
                 throw new StateQLError("INVALID_SQL", "Exactly one SQL statement is required.");
@@ -40,11 +46,15 @@ export function analyzeSql(sql, driver) {
         if (statementType === "select" && selectContainsWrite(ast)) {
             throw new StateQLError("INVALID_SQL", "Read statements cannot contain writes or SELECT INTO.");
         }
-        const normalized = parser
-            .sqlify(ast, { database })
-            .replace(/;\s*$/, "")
-            .replace(/\s+/g, " ")
-            .trim();
+        const normalized = parserSql === trimmed
+            ? parser
+                .sqlify(ast, { database })
+                .replace(/;\s*$/, "")
+                .replace(/\s+/g, " ")
+                .trim()
+            // Keep the exact ordering modifiers in cache and idempotency fingerprints.
+            // The parser copy is analysis-only; adapters execute the original SQL.
+            : trimmed.replace(/;\s*$/, "");
         const details = ast;
         const read = statementType === "select";
         const mutation = statementType === "update" ||
@@ -74,6 +84,151 @@ export function analyzeSql(sql, driver) {
         throw new StateQLError("INVALID_SQL", message);
     }
 }
+function postgresParserSql(sql) {
+    const output = sql.split("");
+    const orderDepths = new Set();
+    let previousWord;
+    let changed = false;
+    let depth = 0;
+    let index = 0;
+    while (index < sql.length) {
+        if (sql.startsWith("--", index)) {
+            index = lineCommentEnd(sql, index + 2);
+            continue;
+        }
+        if (sql.startsWith("/*", index)) {
+            index = blockCommentEnd(sql, index + 2);
+            continue;
+        }
+        const character = sql[index];
+        if (character === "'" || character === '"') {
+            previousWord = undefined;
+            index = quotedEnd(sql, index + 1, character);
+            continue;
+        }
+        if (character === "$") {
+            const delimiter = sql.slice(index).match(/^\$(?:[A-Za-z_][A-Za-z0-9_]*)?\$/)?.[0];
+            if (delimiter) {
+                previousWord = undefined;
+                const end = sql.indexOf(delimiter, index + delimiter.length);
+                index = end < 0 ? sql.length : end + delimiter.length;
+                continue;
+            }
+        }
+        if (character === "(") {
+            previousWord = undefined;
+            depth += 1;
+            index += 1;
+            continue;
+        }
+        if (character === ")") {
+            previousWord = undefined;
+            orderDepths.delete(depth);
+            depth = Math.max(0, depth - 1);
+            index += 1;
+            continue;
+        }
+        if (!identifierStart(character)) {
+            if (!/\s/u.test(character))
+                previousWord = undefined;
+            if (character === ";")
+                orderDepths.clear();
+            index += 1;
+            continue;
+        }
+        let end = index + 1;
+        while (identifierPart(sql[end]))
+            end += 1;
+        const word = sql.slice(index, end).toUpperCase();
+        if (word === "NULLS" && orderDepths.has(depth)) {
+            const ordering = triviaEnd(sql, end);
+            const modifier = sql.slice(ordering, ordering + 5).toUpperCase();
+            const length = modifier === "FIRST" ? 5 : modifier.startsWith("LAST") ? 4 : 0;
+            if (length && !identifierPart(sql[ordering + length])) {
+                for (let cursor = index; cursor < end; cursor += 1)
+                    output[cursor] = " ";
+                for (let cursor = ordering; cursor < ordering + length; cursor += 1)
+                    output[cursor] = " ";
+                changed = true;
+                previousWord = undefined;
+                index = ordering + length;
+                continue;
+            }
+        }
+        if (word === "BY" && previousWord === "ORDER")
+            orderDepths.add(depth);
+        if (["LIMIT", "OFFSET", "FETCH", "FOR", "UNION", "INTERSECT", "EXCEPT"].includes(word)) {
+            orderDepths.delete(depth);
+        }
+        previousWord = word === "ORDER" ? word : undefined;
+        index = end;
+    }
+    return changed ? output.join("") : sql;
+}
+function triviaEnd(sql, start) {
+    let index = start;
+    while (index < sql.length) {
+        if (/\s/u.test(sql[index])) {
+            index += 1;
+        }
+        else if (sql.startsWith("--", index)) {
+            index = lineCommentEnd(sql, index + 2);
+        }
+        else if (sql.startsWith("/*", index)) {
+            index = blockCommentEnd(sql, index + 2);
+        }
+        else {
+            break;
+        }
+    }
+    return index;
+}
+function lineCommentEnd(sql, start) {
+    const end = sql.indexOf("\n", start);
+    return end < 0 ? sql.length : end + 1;
+}
+function blockCommentEnd(sql, start) {
+    let depth = 1;
+    let index = start;
+    while (index < sql.length && depth > 0) {
+        if (sql.startsWith("/*", index)) {
+            depth += 1;
+            index += 2;
+        }
+        else if (sql.startsWith("*/", index)) {
+            depth -= 1;
+            index += 2;
+        }
+        else {
+            index += 1;
+        }
+    }
+    return index;
+}
+function quotedEnd(sql, start, quote) {
+    let index = start;
+    while (index < sql.length) {
+        if (sql[index] === "\\" && quote === "'") {
+            index += 2;
+        }
+        else if (sql[index] !== quote) {
+            index += 1;
+        }
+        else if (sql[index + 1] === quote) {
+            index += 2;
+        }
+        else {
+            return index + 1;
+        }
+    }
+    return index;
+}
+function identifierStart(value) {
+    return value !== undefined && /[A-Za-z_\u0080-\uFFFF]/u.test(value);
+}
+function identifierPart(value) {
+    return value !== undefined && /[A-Za-z0-9_$\u0080-\uFFFF]/u.test(value);
+}
 function selectContainsWrite(ast) {
     const details = ast;
     const into = details.into;

package/dist/src/stateql.d.ts

@@ -1,4 +1,4 @@
-import type { ActorLinkData, ActorResolutionData, ActorsData, ActorUnlinkData, AliasData, ApplyData, BatchCommand, BatchOptions, CapabilitiesData, CloseSessionData, ColumnsData, CommitTransactionData, ConnectOptions, ConnectionData, CountData, DisconnectData, DoctorData, ExecData, ExecOptions, ExecutionOptions, ExportData, FilterOptions, HistoryData, OperationData, PlanData, PlanOptions, ProfileData, ProfilesData, ProfileOptions, PurgeData, QueryOptions, RemovedProfileData, Response, ResultData, RollbackTransactionData, RowsData, RowsOptions, StateQLActorOptions, StateQLOptions, StateQLSnapshot, StatusData, SessionData, SessionsData, SessionSummaryData, TransactionData } from "./types.js";
+import type { ActorLinkData, ActorResolutionData, ActorsData, ActorUnlinkData, AliasData, ApplyData, BatchCommand, BatchOptions, CapabilitiesData, CloseSessionData, ColumnsData, CommitTransactionData, ConnectOptions, ConnectionData, CountData, DisconnectData, DoctorData, ExecData, ExecOptions, ExecutionOptions, ExportData, FilterOptions, HistoryData, OperationData, PlanData, PlanOptions, ProfileData, ProfilesData, ProfileOptions, MongoExecOptions, MongoPlanOptions, MongoQueryOptions, MongoReadCommand, MongoWriteCommand, PurgeData, QueryOptions, RemovedProfileData, Response, ResultData, RollbackTransactionData, RowsData, RowsOptions, StateQLActorOptions, StateQLOptions, StateQLSnapshot, StatusData, SessionData, SessionsData, SessionSummaryData, TransactionData } from "./types.js";
 export declare class StateQL {
     static forActor(options: StateQLActorOptions): StateQL;
     private readonly store;
@@ -38,6 +38,7 @@ export declare class StateQL {
     sessionSummary(): Promise<Response<SessionSummaryData>>;
     closeSession(): Promise<Response<CloseSessionData>>;
     query(sql: string, options?: QueryOptions): Promise<Response<ResultData>>;
+    mongoQuery(command: MongoReadCommand, options?: MongoQueryOptions): Promise<Response<ResultData>>;
     show(idOrAlias: string): Promise<Response<ResultData>>;
     filter(idOrAlias: string, predicate: string, options?: FilterOptions): Promise<Response<ResultData>>;
     rows(idOrAlias: string, options?: RowsOptions): Promise<Response<RowsData>>;
@@ -46,6 +47,7 @@ export declare class StateQL {
     setAlias(name: string, id: string): Promise<Response<AliasData>>;
     exportResult(idOrAlias: string, output: string, format?: "json" | "jsonl" | "csv"): Promise<Response<ExportData>>;
     exec(sql: string, options?: ExecOptions): Promise<Response<ExecData>>;
+    mongoExec(command: MongoWriteCommand, options?: MongoExecOptions): Promise<Response<ExecData>>;
     receipt(id: string): Promise<Response<OperationData>>;
     beginTransaction(isolation?: string): Promise<Response<TransactionData>>;
     transactionStatus(id?: string): Promise<Response<TransactionData>>;
@@ -53,6 +55,7 @@ export declare class StateQL {
     rollbackTransaction(id?: string): Promise<Response<RollbackTransactionData>>;
     inspect(kind: string, table?: string, options?: ExecutionOptions): Promise<Response<unknown>>;
     plan(sql: string, options?: PlanOptions): Promise<Response<PlanData>>;
+    mongoPlan(command: MongoWriteCommand, options?: MongoPlanOptions): Promise<Response<PlanData>>;
     apply(planId: string, options?: ExecutionOptions): Promise<Response<ApplyData>>;
     history(limit?: number): Promise<Response<HistoryData>>;
     doctor(): Promise<Response<DoctorData>>;
@@ -61,11 +64,14 @@ export declare class StateQL {
     executeCommand(command: BatchCommand): Promise<Response<unknown>>;
     batch(commands: Iterable<BatchCommand> | AsyncIterable<BatchCommand>, options?: BatchOptions): AsyncGenerator<Response<unknown>>;
     private performExec;
+    private performMongoExec;
     private batchFailure;
     private withResult;
     private rejectDuringStagedTransaction;
     private requireResult;
     private requireConnection;
+    private requireMongoConnection;
+    private rejectMongoSql;
     private requireActiveTransaction;
     private requireSelectedSession;
     private validateActorId;
@@ -73,6 +79,7 @@ export declare class StateQL {
     private resolveConnectionSource;
     private resolveCredential;
     private openAdapter;
+    private openMongoAdapter;
     private executionContext;
     private resultData;
     private cacheValid;