csv-sql-engine 0.0.0 → 0.0.1

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

@@ -0,0 +1,51 @@
+import { check } from '@augment-vir/assert';
+import { awaitedBlockingMap } from '@augment-vir/common';
+import { nameCsvTableFile, readCsvFile, readCsvHeaders, writeCsvFile } from '../../csv/csv-file.js';
+import { sortValues } from '../../csv/csv-text.js';
+import { AstType } from '../../sql/ast.js';
+import { defineAstHandler } from '../define-ast-handler.js';
+import { findWhereMatches } from '../where-matcher.js';
+/**
+ * Handles deleting rows.
+ *
+ * @category SQL Handler
+ */
+export const rowDeleteHandler = defineAstHandler({
+    name: 'row-delete',
+    async handler({ ast, csvDirPath }) {
+        if (ast.type === AstType.Delete) {
+            const tableNames = ast.table.map((table) => table.table);
+            const returning = 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 returning = returningRequirement
+                    ? csvContents
+                        .filter((row, index) => rowIndexesToDelete.includes(index))
+                        .map((row) => sortValues({
+                        csvFileHeaderOrder: csvHeaders,
+                        sqlQueryHeaderOrder: returningRequirement.columns.map((column) => column.expr.column),
+                        from: {
+                            csvFile: row,
+                        },
+                    }))
+                    : undefined;
+                rowIndexesToDelete.forEach((rowIndexToDelete) => {
+                    csvContents.splice(rowIndexToDelete, 1);
+                });
+                await writeCsvFile(tableFilePath, csvContents);
+                return returning;
+            });
+            return returning.flat().filter(check.isTruthy);
+        }
+        return undefined;
+    },
+});

package/dist/engine/handlers/row-insert.handler.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Handles inserting rows.
+ *
+ * @category SQL Handler
+ */
+export declare const rowInsertHandler: import("../define-ast-handler.js").AstHandler;

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

@@ -0,0 +1,54 @@
+import { check } from '@augment-vir/assert';
+import { awaitedBlockingMap } from '@augment-vir/common';
+import { appendCsvRow, nameCsvTableFile, readCsvHeaders } from '../../csv/csv-file.js';
+import { sortValues } from '../../csv/csv-text.js';
+import { AstType } from '../../sql/ast.js';
+import { defineAstHandler } from '../define-ast-handler.js';
+/**
+ * Handles inserting rows.
+ *
+ * @category SQL Handler
+ */
+export const rowInsertHandler = defineAstHandler({
+    name: 'row-insert',
+    async handler({ ast, csvDirPath }) {
+        if (ast.type === AstType.Insert) {
+            const tableNames = ast.table.map((table) => table.table);
+            const returning = 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 values = ast.columns
+                    ? sortValues({
+                        csvFileHeaderOrder,
+                        sqlQueryHeaderOrder: ast.columns,
+                        from: {
+                            sqlQuery: rawValues,
+                        },
+                    })
+                    : rawValues;
+                await appendCsvRow(values, tableFilePath);
+                if (ast.returning) {
+                    return sortValues({
+                        csvFileHeaderOrder,
+                        sqlQueryHeaderOrder: ast.returning.columns.map((column) => column.expr.column),
+                        from: {
+                            csvFile: values,
+                        },
+                    });
+                }
+                else {
+                    return undefined;
+                }
+            });
+            return returning.filter(check.isTruthy);
+        }
+        return undefined;
+    },
+});

package/dist/engine/handlers/row-select.handler.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Handles SQL selection.
+ *
+ * @category SQL Handler
+ */
+export declare const rowSelectHandler: import("../define-ast-handler.js").AstHandler;

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

@@ -0,0 +1,46 @@
+import { check } from '@augment-vir/assert';
+import { awaitedBlockingMap } from '@augment-vir/common';
+import { nameCsvTableFile, readCsvFile, readCsvHeaders, writeCsvFile } from '../../csv/csv-file.js';
+import { sortValues } from '../../csv/csv-text.js';
+import { AstType } from '../../sql/ast.js';
+import { defineAstHandler } from '../define-ast-handler.js';
+import { findWhereMatches } from '../where-matcher.js';
+/**
+ * Handles SQL selection.
+ *
+ * @category SQL Handler
+ */
+export const rowSelectHandler = defineAstHandler({
+    name: 'row-select',
+    async handler({ ast, csvDirPath }) {
+        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);
+                const selection = csvContents
+                    .filter((row, index) => rowIndexesToSelect.includes(index))
+                    .map((row) => sortValues({
+                    csvFileHeaderOrder: csvHeaders,
+                    sqlQueryHeaderOrder: columnNames,
+                    from: {
+                        csvFile: row,
+                    },
+                }));
+                await writeCsvFile(tableFilePath, csvContents);
+                return selection;
+            });
+            return allSelections.flat().filter(check.isTruthy);
+        }
+        return undefined;
+    },
+});

package/dist/engine/handlers/row-update.handler.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Handles updating rows.
+ *
+ * @category SQL Handler
+ */
+export declare const rowUpdateHandler: import("../define-ast-handler.js").AstHandler;

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

@@ -0,0 +1,61 @@
+import { assertWrap, check } from '@augment-vir/assert';
+import { awaitedBlockingMap } from '@augment-vir/common';
+import { createCsvHeaderMaps, nameCsvTableFile, readCsvFile, readCsvHeaders, writeCsvFile, } from '../../csv/csv-file.js';
+import { sortValues } from '../../csv/csv-text.js';
+import { CsvColumnDoesNotExistError } from '../../errors/csv.error.js';
+import { AstType } from '../../sql/ast.js';
+import { defineAstHandler } from '../define-ast-handler.js';
+import { findWhereMatches } from '../where-matcher.js';
+/**
+ * Handles updating rows.
+ *
+ * @category SQL Handler
+ */
+export const rowUpdateHandler = defineAstHandler({
+    name: 'row-update',
+    async handler({ ast, csvDirPath }) {
+        if (ast.type === AstType.Update) {
+            const tableNames = ast.table.map((table) => table.table);
+            const returning = 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 returning = returningRequirement
+                    ? csvContents
+                        .filter((row, index) => rowIndexesToUpdate.includes(index))
+                        .map((row) => sortValues({
+                        csvFileHeaderOrder: csvHeaders,
+                        sqlQueryHeaderOrder: returningRequirement.columns.map((column) => column.expr.column),
+                        from: {
+                            csvFile: row,
+                        },
+                    }))
+                    : undefined;
+                await writeCsvFile(tableFilePath, csvContents);
+                return returning;
+            });
+            return returning.flat().filter(check.isTruthy);
+        }
+        return undefined;
+    },
+});

package/dist/engine/handlers/table-alter.handler.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Handles altering tables.
+ *
+ * @category SQL Handler
+ */
+export declare const tableAlterHandler: import("../define-ast-handler.js").AstHandler;

package/dist/engine/handlers/table-alter.handler.js

@@ -0,0 +1,85 @@
+import { assert } from '@augment-vir/assert';
+import { awaitedForEach, stringify } from '@augment-vir/common';
+import { existsSync } from 'node:fs';
+import { nameCsvTableFile, readCsvFile, readCsvHeaders, writeCsvFile } from '../../csv/csv-file.js';
+import { CsvColumnDoesNotExistError, CsvTableDoesNotExistError } from '../../errors/csv.error.js';
+import { AlterExpressionAction } from '../../sql/ast.js';
+import { defineAstHandler } from '../define-ast-handler.js';
+/**
+ * Handles altering tables.
+ *
+ * @category SQL Handler
+ */
+export const tableAlterHandler = defineAstHandler({
+    name: 'table-alter',
+    async handler({ ast, csvDirPath }) {
+        if (ast.type === 'alter') {
+            const tableNames = ast.table.map((table) => table.table);
+            await awaitedForEach(tableNames, async (tableName) => {
+                await awaitedForEach(ast.expr, async (expression) => {
+                    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,
+                    });
+                    if (expression.action === AlterExpressionAction.Add) {
+                        const defaultValue = expression.default_val?.value.value || '';
+                        const newHeaderName = expression.column.column;
+                        csvContents.forEach((row, index) => {
+                            if (index) {
+                                row.push(defaultValue);
+                            }
+                            else {
+                                row.push(newHeaderName);
+                            }
+                        });
+                    }
+                    else if (expression.action === AlterExpressionAction.Rename) {
+                        const oldHeaderName = expression.old_column.column;
+                        const newHeaderName = expression.column.column;
+                        let oldHeaderFound = false;
+                        const newHeaders = csvHeaders.map((header) => {
+                            if (header === oldHeaderName) {
+                                oldHeaderFound = true;
+                                return newHeaderName;
+                            }
+                            else {
+                                return header;
+                            }
+                        });
+                        if (!oldHeaderFound) {
+                            throw new CsvColumnDoesNotExistError(sanitizedTableName, oldHeaderName);
+                        }
+                        csvContents[0] = newHeaders;
+                        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                    }
+                    else if (expression.action === AlterExpressionAction.Drop) {
+                        const columnName = expression.column.column;
+                        const columnIndex = csvHeaders.indexOf(columnName);
+                        if (columnIndex < 0) {
+                            throw new CsvColumnDoesNotExistError(sanitizedTableName, columnName);
+                        }
+                        csvContents.forEach((row) => {
+                            row.splice(columnIndex, 1);
+                        });
+                    }
+                    else {
+                        assert.tsType(expression).equals();
+                        assert.never(`Forgot to handle expression action ${stringify(expression)}`);
+                    }
+                    await writeCsvFile(tableFilePath, csvContents);
+                });
+            });
+            return [];
+        }
+        return undefined;
+    },
+});

package/dist/engine/handlers/table-create.handler.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Handles creating tables.
+ *
+ * @category SQL Handler
+ */
+export declare const tableCreateHandler: import("../define-ast-handler.js").AstHandler;

package/dist/engine/handlers/table-create.handler.js

@@ -0,0 +1,38 @@
+import { check } from '@augment-vir/assert';
+import { awaitedForEach, filterMap } from '@augment-vir/common';
+import { existsSync } from 'node:fs';
+import { appendCsvRow, nameCsvTableFile } from '../../csv/csv-file.js';
+import { CsvTableExistsError } from '../../errors/csv.error.js';
+import { SqlMissingColumnsError } from '../../errors/sql.error.js';
+import { AstType, CreateKeyword } from '../../sql/ast.js';
+import { defineAstHandler } from '../define-ast-handler.js';
+/**
+ * Handles creating tables.
+ *
+ * @category SQL Handler
+ */
+export const tableCreateHandler = defineAstHandler({
+    name: 'table-create',
+    async handler({ ast, csvDirPath, sql }) {
+        if (ast.type === AstType.Create && ast.keyword === CreateKeyword.Table) {
+            await awaitedForEach(ast.table, async (table) => {
+                const { tableFilePath, sanitizedTableName } = nameCsvTableFile({
+                    csvDirPath,
+                    tableName: table.table,
+                });
+                if (existsSync(tableFilePath)) {
+                    throw new CsvTableExistsError(sanitizedTableName);
+                }
+                const headers = filterMap(ast.create_definitions, (definition) => {
+                    return definition.column.column;
+                }, check.isTruthy);
+                if (!headers.length) {
+                    throw new SqlMissingColumnsError(sql, sanitizedTableName);
+                }
+                await appendCsvRow(headers, tableFilePath);
+            });
+            return [];
+        }
+        return undefined;
+    },
+});

package/dist/engine/handlers/table-drop.handler.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Handles dropping tables.
+ *
+ * @category SQL Handler
+ */
+export declare const tableDropHandler: import("../define-ast-handler.js").AstHandler;

package/dist/engine/handlers/table-drop.handler.js

@@ -0,0 +1,36 @@
+import { awaitedForEach } from '@augment-vir/common';
+import { existsSync } from 'node:fs';
+import { rm } from 'node:fs/promises';
+import { nameCsvTableFile } from '../../csv/csv-file.js';
+import { CsvTableDoesNotExistError } from '../../errors/csv.error.js';
+import { AstType } from '../../sql/ast.js';
+import { defineAstHandler } from '../define-ast-handler.js';
+/**
+ * Handles dropping tables.
+ *
+ * @category SQL Handler
+ */
+export const tableDropHandler = defineAstHandler({
+    name: 'table-drop',
+    async handler({ ast, csvDirPath }) {
+        if (ast.type === AstType.Drop) {
+            await awaitedForEach(ast.name, async (table) => {
+                const { tableFilePath, sanitizedTableName } = nameCsvTableFile({
+                    csvDirPath,
+                    tableName: table.table,
+                });
+                if (existsSync(tableFilePath)) {
+                    await rm(tableFilePath);
+                }
+                else if (ast.prefix === 'if exists') {
+                    return;
+                }
+                else {
+                    throw new CsvTableDoesNotExistError(sanitizedTableName);
+                }
+            });
+            return [];
+        }
+        return undefined;
+    },
+});

package/dist/engine/params.d.ts

@@ -0,0 +1,51 @@
+import { type PartialWithUndefined } from '@augment-vir/common';
+import { type Parser } from 'node-sql-parser';
+import { type SqlAst } from '../sql/ast.js';
+import { type Sql } from '../sql/sql.js';
+/**
+ * Options for rejecting unsupported operations (rather than ignoring them).
+ *
+ * @category Internal
+ */
+export type RejectUnsupportedOptions = PartialWithUndefined<{
+    /**
+     * - If set to `true`, unsupported operations will throw errors.
+     * - When left to `false`, unsupported operations are simply ignored.
+     *
+     * @default false
+     */
+    rejectUnsupportedOperations: boolean;
+}>;
+/**
+ * Options for parsing SQL.
+ *
+ * @category Internal
+ */
+export type ParseSqlOptions = PartialWithUndefined<{
+    /**
+     * A custom implementation of the Parser from
+     * [node-sql-parser](https://npmjs.com/package/node-sql-parser). If not provided, one will be
+     * constructed.
+     */
+    parser: Parser;
+}> & RejectUnsupportedOptions;
+/**
+ * Parameters for AST handlers.
+ *
+ * @category Internal
+ */
+export type AstHandlerParams = {
+    ast: SqlAst;
+    sql: Sql;
+    /**
+     * Path to the folder or directory containing all the CSV files. (Each CSV file is treated as an
+     * individual table.)
+     */
+    csvDirPath: string;
+} & RejectUnsupportedOptions;
+/**
+ * Parameters for executing SQL.
+ *
+ * @category Internal
+ */
+export type ExecuteSqlParams = ParseSqlOptions & Omit<AstHandlerParams, 'ast' | 'sql'>;

package/dist/engine/params.js

@@ -0,0 +1 @@
+export {};

package/dist/engine/where-matcher.d.ts

@@ -0,0 +1,9 @@
+import { type CsvFile } from '../csv/csv-file.js';
+import { type Where } from '../sql/ast.js';
+/**
+ * Finds all row indexes that match the given SQL where conditions.
+ *
+ * @category Internal
+ * @returns An array of row indexes that match the given where condition.
+ */
+export declare function findWhereMatches(where: Readonly<Where>, csvContents: Readonly<CsvFile>, csvFilePath: string): number[];

package/dist/engine/where-matcher.js

@@ -0,0 +1,52 @@
+import { assert } from '@augment-vir/assert';
+import { extractDuplicates, filterMap, removeDuplicates, removeSuffix } from '@augment-vir/common';
+import { csvExtension } from '../csv/csv-file.js';
+import { CsvColumnDoesNotExistError, CsvFileMissingHeadersError } from '../errors/csv.error.js';
+import { WhereOperator } from '../sql/ast.js';
+/**
+ * Finds all row indexes that match the given SQL where conditions.
+ *
+ * @category Internal
+ * @returns An array of row indexes that match the given where condition.
+ */
+export function findWhereMatches(where, csvContents, csvFilePath) {
+    /**
+     * These must be sorted from greatest to least so that deleting rows does not mess up the
+     * indexes.
+     */
+    return innerFindWhereMatches(where, csvContents, csvFilePath).sort((a, b) => b - a);
+}
+function innerFindWhereMatches(where, csvContents, csvFilePath) {
+    if (where.operator === WhereOperator.Or) {
+        return removeDuplicates([
+            ...innerFindWhereMatches(where.left, csvContents, csvFilePath),
+            ...innerFindWhereMatches(where.right, csvContents, csvFilePath),
+        ]);
+    }
+    else if (where.operator === WhereOperator.And) {
+        return extractDuplicates([
+            ...innerFindWhereMatches(where.left, csvContents, csvFilePath),
+            ...innerFindWhereMatches(where.right, csvContents, csvFilePath),
+        ]).duplicates;
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    }
+    else if (where.operator === WhereOperator.Equals) {
+        const headers = csvContents[0];
+        if (!headers) {
+            throw new CsvFileMissingHeadersError(csvFilePath);
+        }
+        const columnIndex = headers.indexOf(where.left.column);
+        if (columnIndex < 0) {
+            throw new CsvColumnDoesNotExistError(removeSuffix({ value: csvFilePath, suffix: csvExtension }), where.left.column);
+        }
+        return filterMap(csvContents, (row, index) => index, (index, row) => {
+            /** Don't select from the header row. */
+            const isHeaderRow = !index;
+            return !isHeaderRow && String(row[columnIndex]) === String(where.right.value);
+        });
+    }
+    else {
+        assert.tsType(where.operator).equals();
+        throw new Error(`Forgot to implement WHERE operation: '${String(where.operator)}'`);
+    }
+}

package/dist/errors/csv-sql-engine.error.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Generic error thrown by the csv-sql-engine package. All known errors from this package extend
+ * this error class.
+ *
+ * @category Error
+ */
+export declare class CsvSqlEngineError extends Error {
+    readonly name: string;
+}

package/dist/errors/csv-sql-engine.error.js

@@ -0,0 +1,9 @@
+/**
+ * Generic error thrown by the csv-sql-engine package. All known errors from this package extend
+ * this error class.
+ *
+ * @category Error
+ */
+export class CsvSqlEngineError extends Error {
+    name = 'CsvSqlEngineError';
+}

package/dist/errors/csv.error.d.ts

@@ -0,0 +1,57 @@
+import { CsvSqlEngineError } from './csv-sql-engine.error.js';
+/**
+ * Generic CSV related error thrown by the csv-sql-engine package. All CSV related errors from this
+ * package extend this error class.
+ *
+ * @category Error
+ */
+export declare class CsvError extends CsvSqlEngineError {
+    readonly name: string;
+}
+/**
+ * Indicates that an table CSV file already exists when it shouldn't.
+ *
+ * @category Error
+ */
+export declare class CsvTableExistsError extends CsvError {
+    readonly name: string;
+    constructor(tableName: string);
+}
+/**
+ * Indicates that an expected table CSV file does not actually exist.
+ *
+ * @category Error
+ */
+export declare class CsvTableDoesNotExistError extends CsvError {
+    readonly name: string;
+    constructor(tableName: string);
+}
+/**
+ * Indicates that parsing of an existing CSV file failed.
+ *
+ * @category Error
+ */
+export declare class CsvParseError extends CsvError {
+    readonly name: string;
+}
+/**
+ * Indicates that a CSV file is missing headers.
+ *
+ * @category Error
+ */
+export declare class CsvFileMissingHeadersError extends CsvParseError {
+    readonly csvFilePath: string;
+    readonly name: string;
+    constructor(csvFilePath: string);
+}
+/**
+ * Indicates that an expected column in a CSV file does not actually exist.
+ *
+ * @category Error
+ */
+export declare class CsvColumnDoesNotExistError extends CsvError {
+    readonly sanitizedTableName: string;
+    readonly missingColumName: string;
+    readonly name: string;
+    constructor(sanitizedTableName: string, missingColumName: string);
+}