csv-sql-engine 0.1.0 → 0.3.0

package/dist/engine/define-ast-handler.d.ts

@@ -1,13 +1,13 @@
 import { type MaybePromise } from '@augment-vir/common';
 import { type AstHandlerParams } from './params.js';
+import { type SortValuesOutput } from './sort-values.js';
 /**
  * Output from a handler that handled a SQL query.
  *
  * @category Internal
  */
-export type AstHandlerResult = {
-    columnNames: string[];
-    values: string[][];
+export type AstHandlerResult = SortValuesOutput & {
+    numberOfRowsAffected: number;
 };
 /**
  * An AST / SQL handler.
@@ -20,7 +20,7 @@ export type AstHandler = {
      * Return `undefined` to mark this AST as not-handled. That means that other handlers should be
      * used instead.
      */
-    handler: (params: Readonly<AstHandlerParams>) => MaybePromise<AstHandlerResult[] | undefined>;
+    handler: (params: Readonly<AstHandlerParams>) => MaybePromise<AstHandlerResult | undefined>;
 };
 /**
  * Used to define new handlers.

package/dist/engine/engine.d.ts

@@ -1,4 +1,4 @@
-import { type Sql } from '../sql/sql.js';
+import { type Sql } from 'sqlite-ast';
 import { type AstHandler, type AstHandlerResult } from './define-ast-handler.js';
 import { type ExecuteSqlParams } from './params.js';
 /**
@@ -13,4 +13,4 @@ export declare const allAstHandlers: ReadonlyArray<Readonly<AstHandler>>;
  *
  * @category Main
  */
-export declare function executeSql(sqlInput: Sql | string, params: Readonly<ExecuteSqlParams>): Promise<AstHandlerResult[][]>;
+export declare function executeSql(sqlInput: Sql | string, params: Readonly<ExecuteSqlParams>): Promise<AstHandlerResult[]>;

package/dist/engine/engine.js

@@ -1,9 +1,8 @@
 import { check } from '@augment-vir/assert';
-import { awaitedBlockingMap, ensureErrorAndPrependMessage } from '@augment-vir/common';
+import { awaitedBlockingMap, ensureErrorAndPrependMessage, wrapInTry, } from '@augment-vir/common';
 import { mkdir } from 'node:fs/promises';
-import { SqlUnsupportedOperationError } from '../errors/sql.error.js';
-import { parseSql } from '../sql/parse-sql.js';
-import { rawSql } from '../sql/sql.js';
+import { parseSqlite, rawSql } from 'sqlite-ast';
+import { SqlParseError, SqlUnsupportedOperationError } from '../errors/sql.error.js';
 import { rowDeleteHandler } from './handlers/row-delete.handler.js';
 import { rowInsertHandler } from './handlers/row-insert.handler.js';
 import { rowSelectHandler } from './handlers/row-select.handler.js';
@@ -34,33 +33,38 @@ export const allAstHandlers = [
 export async function executeSql(sqlInput, params) {
     // eslint-disable-next-line @typescript-eslint/no-deprecated
     const sql = check.isString(sqlInput) ? rawSql(sqlInput) : sqlInput;
-    const astResults = parseSql(sql, params);
+    const astList = wrapInTry(() => parseSqlite(sql), {
+        handleError(error) {
+            throw new SqlParseError(sql, error);
+        },
+    });
     await mkdir(params.csvDirPath, {
         recursive: true,
     });
-    return await awaitedBlockingMap(astResults, async (ast) => {
+    return (await awaitedBlockingMap(astList, async (ast) => {
         return await executeIndividualCommand({
             ...params,
             ast,
             sql,
         });
-    });
+    })).filter(check.isTruthy);
 }
 async function executeIndividualCommand(params) {
     try {
         for (const handler of allAstHandlers) {
             const output = await handler.handler(params);
             if (output) {
-                return output.filter((entry) => entry.values.length);
+                return output;
             }
         }
         /** If nothing handled the query, then we don't support it. */
         if (params.rejectUnsupportedOperations) {
-            throw new SqlUnsupportedOperationError(params.sql, undefined);
+            throw new SqlUnsupportedOperationError(params.sql, undefined, params.ast);
         }
-        return [];
+        return undefined;
     }
     catch (error) {
-        throw ensureErrorAndPrependMessage(error, `Failed to execute '${params.ast.type}' command.`);
+        const errorAst = params.ast;
+        throw ensureErrorAndPrependMessage(error, `Failed to execute '${errorAst.variant || errorAst.type}' command.`);
     }
 }

package/dist/engine/handlers/row-delete.handler.js

@@ -1,7 +1,5 @@
-import { check } from '@augment-vir/assert';
-import { awaitedBlockingMap } from '@augment-vir/common';
 import { nameCsvTableFile, readCsvFile, readCsvHeaders, writeCsvFile } from '../../csv/csv-file.js';
-import { AstType } from '../../sql/ast.js';
+import { getAstType } from '../../util/ast-node.js';
 import { defineAstHandler } from '../define-ast-handler.js';
 import { sortValues } from '../sort-values.js';
 import { findWhereMatches } from '../where-matcher.js';
@@ -13,38 +11,53 @@ import { findWhereMatches } from '../where-matcher.js';
 export const rowDeleteHandler = defineAstHandler({
     name: 'row-delete',
     async handler({ ast, csvDirPath, sql }) {
-        if (ast.type === AstType.Delete) {
-            const tableNames = ast.table.map((table) => table.table);
-            const results = await awaitedBlockingMap(tableNames, async (tableName) => {
-                const { tableFilePath, sanitizedTableName } = nameCsvTableFile({
-                    csvDirPath,
-                    tableName,
-                });
-                const csvContents = await readCsvFile(tableFilePath);
-                const csvHeaders = await readCsvHeaders({
-                    csvContents,
-                    sanitizedTableName,
-                });
-                const rowIndexesToDelete = findWhereMatches(ast.where, csvContents, tableFilePath);
-                const returningRequirement = ast.returning;
-                const result = returningRequirement
-                    ? sortValues({
-                        csvFileHeaderOrder: csvHeaders,
-                        sqlQueryHeaderOrder: returningRequirement.columns.map((column) => column.expr.column),
-                        from: {
-                            csvFile: csvContents.filter((row, index) => rowIndexesToDelete.includes(index)),
-                        },
-                        unconsumedInterpolationValues: sql.unconsumedValues,
-                    })
-                    : undefined;
-                rowIndexesToDelete.forEach((rowIndexToDelete) => {
-                    csvContents.splice(rowIndexToDelete, 1);
-                });
-                await writeCsvFile(tableFilePath, csvContents);
-                return result;
-            });
-            return results.flat().filter(check.isTruthy);
+        if (ast.variant !== 'delete') {
+            return undefined;
         }
-        return undefined;
+        const tableName = getAstType(ast.from, 'identifier')?.name;
+        if (!tableName) {
+            throw new Error('Missing table name.');
+        }
+        const { tableFilePath, sanitizedTableName } = nameCsvTableFile({
+            csvDirPath,
+            tableName,
+        });
+        const csvContents = await readCsvFile(tableFilePath);
+        const csvHeaders = await readCsvHeaders({
+            csvContents,
+            sanitizedTableName,
+        });
+        const rowIndexesToDelete = findWhereMatches(ast.where, csvContents, tableFilePath);
+        const returningRequirement = ast.returning;
+        const sqlHeaders = returningRequirement?.map((column) => {
+            const columnNode = getAstType(column, 'identifier');
+            if (columnNode) {
+                return columnNode.name;
+            }
+            else {
+                throw new Error(`Unexpected return column type: ${column.type}`);
+            }
+        }) || [];
+        const result = returningRequirement
+            ? sortValues({
+                csvFileHeaderOrder: csvHeaders,
+                sqlQueryHeaderOrder: sqlHeaders,
+                from: {
+                    csvFile: csvContents.filter((row, index) => rowIndexesToDelete.includes(index)),
+                },
+                unconsumedInterpolationValues: sql.unconsumedValues,
+            })
+            : {
+                columnNames: [],
+                values: [],
+            };
+        rowIndexesToDelete.forEach((rowIndexToDelete) => {
+            csvContents.splice(rowIndexToDelete, 1);
+        });
+        await writeCsvFile(tableFilePath, csvContents);
+        return {
+            ...result,
+            numberOfRowsAffected: rowIndexesToDelete.length,
+        };
     },
 });

package/dist/engine/handlers/row-insert.handler.js

@@ -1,7 +1,9 @@
 import { assertWrap, check } from '@augment-vir/assert';
-import { awaitedBlockingMap } from '@augment-vir/common';
-import { appendCsvRow, nameCsvTableFile, readCsvHeaders } from '../../csv/csv-file.js';
-import { AstType } from '../../sql/ast.js';
+import { filterMap } from '@augment-vir/common';
+import { existsSync } from 'node:fs';
+import { appendCsvRow, nameCsvTableFile, readCsvFile, readCsvHeaders } from '../../csv/csv-file.js';
+import { CsvTableDoesNotExistError } from '../../errors/csv.error.js';
+import { SqlUnsupportedOperationError } from '../../errors/sql.error.js';
 import { defineAstHandler } from '../define-ast-handler.js';
 import { sortValues } from '../sort-values.js';
 /**
@@ -11,45 +13,107 @@ import { sortValues } from '../sort-values.js';
  */
 export const rowInsertHandler = defineAstHandler({
     name: 'row-insert',
-    async handler({ ast, csvDirPath, sql }) {
-        if (ast.type === AstType.Insert) {
-            const tableNames = ast.table.map((table) => table.table);
-            const results = await awaitedBlockingMap(tableNames, async (tableName) => {
-                const { tableFilePath, sanitizedTableName } = nameCsvTableFile({
-                    csvDirPath,
-                    tableName,
-                });
-                const rawValues = ast.values.values.flatMap((value) => value.value.flatMap((value) => String(value.value)));
-                const csvFileHeaderOrder = await readCsvHeaders({
-                    csvFilePath: tableFilePath,
-                    sanitizedTableName,
-                });
-                const newRow = assertWrap.isDefined(sortValues({
-                    csvFileHeaderOrder,
-                    sqlQueryHeaderOrder: ast.columns || csvFileHeaderOrder,
-                    from: {
-                        sqlQuery: [rawValues],
-                    },
-                    unconsumedInterpolationValues: sql.unconsumedValues,
-                }).values[0], 'No sorted row retrieved.');
-                await appendCsvRow(newRow, tableFilePath);
-                if (ast.returning) {
-                    const sqlHeaders = ast.returning.columns.map((column) => column.expr.column);
-                    return sortValues({
-                        csvFileHeaderOrder,
-                        sqlQueryHeaderOrder: sqlHeaders,
-                        from: {
-                            csvFile: [newRow],
-                        },
-                        unconsumedInterpolationValues: undefined,
-                    });
+    async handler({ ast, csvDirPath, sql, rejectUnsupportedOperations }) {
+        if (ast.variant !== 'insert' ||
+            ast.into.type !== 'identifier' ||
+            (ast.into.variant !== 'table' && ast.into.format !== 'table')) {
+            return;
+        }
+        const tableName = ast.into.name;
+        const { tableFilePath, sanitizedTableName } = nameCsvTableFile({
+            csvDirPath,
+            tableName,
+        });
+        if (!existsSync(tableFilePath)) {
+            throw new CsvTableDoesNotExistError(sanitizedTableName);
+        }
+        /** Mutate this to apply the table alterations. */
+        const csvContents = await readCsvFile(tableFilePath);
+        const csvHeaders = await readCsvHeaders({
+            csvContents,
+            sanitizedTableName,
+        });
+        const sqlHeaders = ast.into.columns
+            ? filterMap(ast.into.columns, (column) => {
+                if (column.type === 'identifier' && column.variant === 'column') {
+                    return column.name;
+                }
+                else if (rejectUnsupportedOperations) {
+                    throw new SqlUnsupportedOperationError(sql, `Unsupported column definition: '${JSON.stringify(column)}'`, ast);
                 }
                 else {
                     return undefined;
                 }
-            });
-            return results.filter(check.isTruthy);
+            }, check.isTruthy)
+            : csvHeaders;
+        if (!check.isArray(ast.result)) {
+            if (rejectUnsupportedOperations) {
+                throw new SqlUnsupportedOperationError(sql, `Unsupported result: '${JSON.stringify(ast.result)}'`, ast);
+            }
+            else {
+                return undefined;
+            }
+        }
+        const resultExpression = assertWrap.isTruthy(ast.result[0], 'No result.');
+        if (resultExpression.type !== 'expression' ||
+            resultExpression.variant !== 'list' ||
+            !check.isArray(resultExpression.expression)) {
+            if (rejectUnsupportedOperations) {
+                throw new SqlUnsupportedOperationError(sql, `Expected expression: ${JSON.stringify(resultExpression)}`, ast);
+            }
+            else {
+                return undefined;
+            }
         }
-        return undefined;
+        const rawValues = filterMap(resultExpression.expression, (entry) => {
+            if (entry.type === 'identifier' || entry.type === 'variable') {
+                return entry.name;
+            }
+            else if (entry.type === 'literal') {
+                return entry.value;
+            }
+            else if (rejectUnsupportedOperations) {
+                throw new SqlUnsupportedOperationError(sql, `Unsupported expression entry: ${JSON.stringify(entry)}`, ast);
+            }
+            else {
+                return undefined;
+            }
+        }, check.isTruthy);
+        const newRow = assertWrap.isTruthy(sortValues({
+            csvFileHeaderOrder: csvHeaders,
+            sqlQueryHeaderOrder: sqlHeaders,
+            unconsumedInterpolationValues: sql.unconsumedValues,
+            from: {
+                sqlQuery: [rawValues],
+            },
+        }).values[0], 'No sorted row retrieved.');
+        await appendCsvRow(newRow, tableFilePath);
+        const readResult = ast.returning
+            ? sortValues({
+                csvFileHeaderOrder: csvHeaders,
+                sqlQueryHeaderOrder: filterMap(ast.returning, (entry) => {
+                    if (entry.type === 'identifier') {
+                        return entry.name;
+                    }
+                    else if (rejectUnsupportedOperations) {
+                        throw new Error(`Unsupported returning entry: ${JSON.stringify(entry)}`);
+                    }
+                    else {
+                        return undefined;
+                    }
+                }, check.isTruthy),
+                from: {
+                    csvFile: [newRow],
+                },
+                unconsumedInterpolationValues: undefined,
+            })
+            : {
+                columnNames: [],
+                values: [],
+            };
+        return {
+            ...readResult,
+            numberOfRowsAffected: 1,
+        };
     },
 });

package/dist/engine/handlers/row-select.handler.js

@@ -1,7 +1,8 @@
 import { check } from '@augment-vir/assert';
-import { awaitedBlockingMap } from '@augment-vir/common';
+import { filterMap } from '@augment-vir/common';
 import { nameCsvTableFile, readCsvFile, readCsvHeaders } from '../../csv/csv-file.js';
-import { AstType } from '../../sql/ast.js';
+import { SqlUnsupportedOperationError } from '../../errors/sql.error.js';
+import { getAstType } from '../../util/ast-node.js';
 import { defineAstHandler } from '../define-ast-handler.js';
 import { sortValues } from '../sort-values.js';
 import { findWhereMatches } from '../where-matcher.js';
@@ -12,32 +13,47 @@ import { findWhereMatches } from '../where-matcher.js';
  */
 export const rowSelectHandler = defineAstHandler({
     name: 'row-select',
-    async handler({ ast, csvDirPath, sql }) {
-        if (ast.type === AstType.Select) {
-            const tableNames = ast.from.map((table) => table.table);
-            const allSelections = await awaitedBlockingMap(tableNames, async (tableName) => {
-                const { tableFilePath, sanitizedTableName } = nameCsvTableFile({
-                    csvDirPath,
-                    tableName,
-                });
-                const csvContents = await readCsvFile(tableFilePath);
-                const csvHeaders = await readCsvHeaders({
-                    csvContents,
-                    sanitizedTableName,
-                });
-                const rowIndexesToSelect = findWhereMatches(ast.where, csvContents, tableFilePath);
-                const columnNames = ast.columns.map((column) => column.expr.column);
-                return sortValues({
-                    csvFileHeaderOrder: csvHeaders,
-                    sqlQueryHeaderOrder: columnNames,
-                    from: {
-                        csvFile: csvContents.filter((row, index) => rowIndexesToSelect.includes(index)),
-                    },
-                    unconsumedInterpolationValues: sql.unconsumedValues,
-                });
-            });
-            return allSelections.flat().filter(check.isTruthy);
+    async handler({ ast, csvDirPath, sql, rejectUnsupportedOperations }) {
+        if (ast.variant !== 'select') {
+            return undefined;
         }
-        return undefined;
+        const tableName = getAstType(ast.from, 'identifier')?.name;
+        if (!tableName) {
+            throw new Error('No table name.');
+        }
+        const { tableFilePath, sanitizedTableName } = nameCsvTableFile({
+            csvDirPath,
+            tableName,
+        });
+        const csvContents = await readCsvFile(tableFilePath);
+        const csvHeaders = await readCsvHeaders({
+            csvContents,
+            sanitizedTableName,
+        });
+        const rowIndexesToSelect = findWhereMatches(ast.where, csvContents, tableFilePath);
+        const columnNames = filterMap(ast.result, (result) => {
+            return getAstType(result, 'identifier')?.name;
+        }, (value) => {
+            if (check.isString(value)) {
+                return true;
+            }
+            else if (rejectUnsupportedOperations) {
+                throw new SqlUnsupportedOperationError(sql, 'Result name is not a string.', ast);
+            }
+            else {
+                return false;
+            }
+        });
+        return {
+            ...sortValues({
+                csvFileHeaderOrder: csvHeaders,
+                sqlQueryHeaderOrder: columnNames,
+                from: {
+                    csvFile: csvContents.filter((row, index) => rowIndexesToSelect.includes(index)),
+                },
+                unconsumedInterpolationValues: sql.unconsumedValues,
+            }),
+            numberOfRowsAffected: 0,
+        };
     },
 });

package/dist/engine/handlers/row-update.handler.js

@@ -1,8 +1,7 @@
-import { assertWrap, check } from '@augment-vir/assert';
-import { awaitedBlockingMap } from '@augment-vir/common';
+import { assertWrap } from '@augment-vir/assert';
 import { createCsvHeaderMaps, nameCsvTableFile, readCsvFile, readCsvHeaders, writeCsvFile, } from '../../csv/csv-file.js';
 import { CsvColumnDoesNotExistError } from '../../errors/csv.error.js';
-import { AstType } from '../../sql/ast.js';
+import { getAstType } from '../../util/ast-node.js';
 import { defineAstHandler } from '../define-ast-handler.js';
 import { sortValues } from '../sort-values.js';
 import { findWhereMatches } from '../where-matcher.js';
@@ -14,48 +13,66 @@ import { findWhereMatches } from '../where-matcher.js';
 export const rowUpdateHandler = defineAstHandler({
     name: 'row-update',
     async handler({ ast, csvDirPath, sql }) {
-        if (ast.type === AstType.Update) {
-            const tableNames = ast.table.map((table) => table.table);
-            const results = await awaitedBlockingMap(tableNames, async (tableName) => {
-                const { tableFilePath, sanitizedTableName } = nameCsvTableFile({
-                    csvDirPath,
-                    tableName,
-                });
-                const csvContents = await readCsvFile(tableFilePath);
-                const csvHeaders = await readCsvHeaders({
-                    csvContents,
-                    sanitizedTableName,
-                });
-                const csvHeaderIndexes = createCsvHeaderMaps(csvHeaders);
-                const rowIndexesToUpdate = findWhereMatches(ast.where, csvContents, tableFilePath);
-                const returningRequirement = ast.returning;
-                rowIndexesToUpdate.forEach((rowIndexToUpdate) => {
-                    const row = assertWrap.isDefined(csvContents[rowIndexToUpdate], `Invalid row index '${rowIndexToUpdate}'.`);
-                    ast.set.forEach((set) => {
-                        const columnName = set.column;
-                        const headerIndex = csvHeaderIndexes.byName[columnName];
-                        if (!headerIndex) {
-                            throw new CsvColumnDoesNotExistError(sanitizedTableName, columnName);
-                        }
-                        row[headerIndex] = set.value.value;
-                    });
-                });
-                const sqlHeaders = returningRequirement?.columns.map((column) => column.expr.column) || [];
-                const result = returningRequirement
-                    ? sortValues({
-                        csvFileHeaderOrder: csvHeaders,
-                        sqlQueryHeaderOrder: sqlHeaders,
-                        from: {
-                            csvFile: csvContents.filter((row, index) => rowIndexesToUpdate.includes(index)),
-                        },
-                        unconsumedInterpolationValues: sql.unconsumedValues,
-                    })
-                    : undefined;
-                await writeCsvFile(tableFilePath, csvContents);
-                return result;
-            });
-            return results.flat().filter(check.isTruthy);
+        if (ast.variant !== 'update') {
+            return undefined;
+        }
+        const tableName = getAstType(ast.into, 'identifier')?.name;
+        if (!tableName) {
+            throw new Error('No table name');
         }
-        return undefined;
+        const { tableFilePath, sanitizedTableName } = nameCsvTableFile({
+            csvDirPath,
+            tableName,
+        });
+        const csvContents = await readCsvFile(tableFilePath);
+        const csvHeaders = await readCsvHeaders({
+            csvContents,
+            sanitizedTableName,
+        });
+        const csvHeaderIndexes = createCsvHeaderMaps(csvHeaders);
+        const rowIndexesToUpdate = findWhereMatches(ast.where, csvContents, tableFilePath);
+        const returningRequirement = ast.returning;
+        rowIndexesToUpdate.forEach((rowIndexToUpdate) => {
+            const row = assertWrap.isTruthy(csvContents[rowIndexToUpdate], `Invalid row index '${rowIndexToUpdate}'.`);
+            ast.set.forEach((set) => {
+                const columnName = set.target.name;
+                const headerIndex = csvHeaderIndexes.byName[columnName];
+                if (!headerIndex) {
+                    throw new CsvColumnDoesNotExistError(sanitizedTableName, columnName);
+                }
+                const valueNode = getAstType(set.value, 'literal');
+                if (!valueNode) {
+                    throw new Error(`Unexpected set type: ${set.value.type}`);
+                }
+                row[headerIndex] = valueNode.value;
+            });
+        });
+        const sqlHeaders = returningRequirement?.map((column) => {
+            const columnNode = getAstType(column, 'identifier');
+            if (columnNode) {
+                return columnNode.name;
+            }
+            else {
+                throw new Error(`Unexpected return column type: ${column.type}`);
+            }
+        }) || [];
+        const result = returningRequirement
+            ? sortValues({
+                csvFileHeaderOrder: csvHeaders,
+                sqlQueryHeaderOrder: sqlHeaders,
+                from: {
+                    csvFile: csvContents.filter((row, index) => rowIndexesToUpdate.includes(index)),
+                },
+                unconsumedInterpolationValues: sql.unconsumedValues,
+            })
+            : {
+                columnNames: [],
+                values: [],
+            };
+        await writeCsvFile(tableFilePath, csvContents);
+        return {
+            ...result,
+            numberOfRowsAffected: rowIndexesToUpdate.length,
+        };
     },
 });