+ ) => ReactElement;
}) {
const { isFocus, isSelected, isBorderBottom, isBorderRight } =
state.getCellStatus(rowIndex, colIndex);
@@ -49,7 +55,7 @@ export default function OptimizeTableCell({
}
const cellClassName = cn(
- "box-border hover:bg-neutral-100 dark:hover:bg-neutral-800",
+ "overflow-hidden border-r border-b box-border hover:bg-neutral-100 dark:hover:bg-neutral-800",
isSelected && "border-neutral-950 dark:border-neutral-50",
isBorderBottom && "border-b border-b-neutral-950 dark:border-b-neutral-50",
isBorderRight && "border-r border-r-neutral-950 dark:border-r-neutral-50",
@@ -59,8 +65,6 @@ export default function OptimizeTableCell({
cellBackgroundColor
);
- const className = cn("libsql-table-cell");
-
return (
-
- {tableResultCellRenderer({
+
+ {renderCell({
x: colIndex,
y: rowIndex,
state: state,
diff --git a/src/components/gui/table-optimized/table-fake-body-padding.tsx b/src/components/gui/table-optimized/table-fake-body-padding.tsx
index 1c2945c4..99449f06 100644
--- a/src/components/gui/table-optimized/table-fake-body-padding.tsx
+++ b/src/components/gui/table-optimized/table-fake-body-padding.tsx
@@ -18,9 +18,9 @@ export default function TableFakeBodyPadding({
const paddingBottom = (rowCount - rowEnd) * rowHeight;
return (
-
+
{!!paddingTop && (
-
+
|
+ |
({
headers,
onHeaderResize,
renderHeader,
@@ -11,25 +11,22 @@ export default function TableHeaderList({
onHeaderContextMenu,
state,
}: {
- headers: OptimizeTableHeaderWithIndexProps[];
+ headers: OptimizeTableHeaderWithIndexProps[];
renderHeader: (
- props: OptimizeTableHeaderWithIndexProps,
- idx: number
+ props: OptimizeTableHeaderWithIndexProps
) => ReactElement;
onHeaderResize: (idx: number, newWidth: number) => void;
sticky: boolean;
onHeaderContextMenu?: (
e: React.MouseEvent,
- header: OptimizeTableHeaderWithIndexProps
+ header: OptimizeTableHeaderWithIndexProps
) => void;
- state: OptimizeTableState;
+ state: OptimizeTableState;
}) {
return (
-
-
- |
-
- |
+
+
+ |
{headers.map((header, idx) => {
return (
setResizing(true)}
>
diff --git a/src/components/gui/table-optimized/table-header.tsx b/src/components/gui/table-optimized/table-header.tsx
index 80cbbc8f..ad3f45c0 100644
--- a/src/components/gui/table-optimized/table-header.tsx
+++ b/src/components/gui/table-optimized/table-header.tsx
@@ -4,7 +4,7 @@ import type { OptimizeTableHeaderWithIndexProps } from ".";
import OptimizeTableState from "./optimize-table-state";
import TableHeaderResizeHandler from "./table-header-resize-handler";
-export default function TableHeader({
+export default function TableHeader({
idx,
header,
onHeaderResize,
@@ -15,16 +15,18 @@ export default function TableHeader({
}: {
idx: number;
sticky: boolean;
- header: OptimizeTableHeaderWithIndexProps;
- state: OptimizeTableState;
+ header: OptimizeTableHeaderWithIndexProps;
+ state: OptimizeTableState;
onHeaderResize: (idx: number, newWidth: number) => void;
onContextMenu?: React.MouseEventHandler;
renderHeader: (
- props: OptimizeTableHeaderWithIndexProps,
- idx: number
+ props: OptimizeTableHeaderWithIndexProps
) => ReactElement;
}) {
- const className = cn(sticky ? "sticky z-30" : undefined, "bg-background");
+ const className = cn(
+ sticky ? "z-30" : undefined,
+ "bg-background border-r border-b overflow-hidden sticky top-0 h-[35px] leading-[35px] flex text-left z-10 p-0"
+ );
return (
- {renderHeader(header, idx)}
+ {renderHeader(header)}
{header.setting.resizable && (
)}
diff --git a/src/components/gui/table-optimized/use-visibility-calculation.ts b/src/components/gui/table-optimized/use-visibility-calculation.ts
index c3fa5872..2b85bcef 100644
--- a/src/components/gui/table-optimized/use-visibility-calculation.ts
+++ b/src/components/gui/table-optimized/use-visibility-calculation.ts
@@ -1,9 +1,70 @@
import useElementResize from "@/components/hooks/useElementResize";
import { useCallback, useEffect, useState } from "react";
import { OptimizeTableHeaderWithIndexProps } from ".";
-import { getVisibleCellRange } from "./helper";
import OptimizeTableState from "./optimize-table-state";
+/**
+ * Giving the container, we calculate visible rows and column
+ *
+ * @param e container elements
+ * @param headerSizes size of each headers
+ * @param totalRowCount total number of rows
+ * @param rowHeight fixed height of each row
+ * @param renderAhead number of rows that we need to pre-render ahead
+ * @returns
+ */
+export function getVisibleCellRange(
+ e: HTMLDivElement,
+ headerSizes: number[],
+ totalRowCount: number,
+ rowHeight: number,
+ renderAhead: number,
+ gutterWidth: number
+) {
+ const currentRowStart = Math.max(
+ 0,
+ Math.floor(e.scrollTop / rowHeight) - 1 - renderAhead
+ );
+ const currentRowEnd = Math.min(
+ totalRowCount,
+ currentRowStart +
+ Math.ceil(e.getBoundingClientRect().height / rowHeight) +
+ renderAhead
+ );
+
+ let currentColStart = -1;
+ let currentColAccumulateSize = gutterWidth;
+ let currentColEnd = -1;
+
+ const visibleXStart = e.scrollLeft;
+ const visibleXEnd = visibleXStart + e.getBoundingClientRect().width;
+
+ for (let i = 0; i < headerSizes.length; i++) {
+ if (currentColAccumulateSize >= visibleXStart && currentColStart < 0) {
+ currentColStart = i - 1;
+ }
+
+ currentColAccumulateSize += headerSizes[i] ?? 0;
+
+ if (currentColAccumulateSize >= visibleXEnd && currentColEnd < 0) {
+ currentColEnd = i;
+ break;
+ }
+ }
+
+ if (currentColEnd < 0) currentColEnd = headerSizes.length - 1;
+ if (currentColStart < 0) currentColStart = 0;
+ if (currentColEnd >= headerSizes.length)
+ currentColEnd = headerSizes.length - 1;
+
+ return {
+ colStart: currentColStart,
+ colEnd: currentColEnd,
+ rowStart: currentRowStart,
+ rowEnd: currentRowEnd,
+ };
+}
+
export default function useTableVisibilityRecalculation({
containerRef,
totalRowCount,
diff --git a/src/components/gui/table-result/context-menu.tsx b/src/components/gui/table-result/context-menu.tsx
index 6e075dc5..ab89da7f 100644
--- a/src/components/gui/table-result/context-menu.tsx
+++ b/src/components/gui/table-result/context-menu.tsx
@@ -11,7 +11,8 @@ import { LucidePlus, LucideTrash2 } from "lucide-react";
import { useCallback } from "react";
import { useFullEditor } from "../providers/full-editor-provider";
import OptimizeTableState from "../table-optimized/optimize-table-state";
-import TableStateActions from "../table-optimized/table-state-actions";
+import TableStateActions from "./table-state-actions";
+import { TableHeaderMetadata } from "./type";
export default function useTableResultContextMenu({
tableName,
@@ -20,9 +21,9 @@ export default function useTableResultContextMenu({
pasteCallback,
}: {
tableName?: string;
- data: OptimizeTableState;
- copyCallback: (state: OptimizeTableState) => void;
- pasteCallback: (state: OptimizeTableState) => void;
+ data: OptimizeTableState;
+ copyCallback: (state: OptimizeTableState) => void;
+ pasteCallback: (state: OptimizeTableState) => void;
}) {
const { openEditor } = useFullEditor();
const { extensions } = useStudioContext();
@@ -32,7 +33,7 @@ export default function useTableResultContextMenu({
state,
event,
}: {
- state: OptimizeTableState;
+ state: OptimizeTableState;
event: React.MouseEvent;
}) => {
const randomUUID = generateId();
diff --git a/src/components/gui/table-result/helper.ts b/src/components/gui/table-result/helper.ts
new file mode 100644
index 00000000..7b9241f4
--- /dev/null
+++ b/src/components/gui/table-result/helper.ts
@@ -0,0 +1,23 @@
+import {
+ buildTableResultHeader,
+ BuildTableResultProps,
+} from "@/lib/build-table-result";
+import OptimizeTableState from "../table-optimized/optimize-table-state";
+import { TableHeaderMetadata } from "./type";
+
+export function createTableStateFromResult(props: BuildTableResultProps) {
+ const r = new OptimizeTableState(
+ buildTableResultHeader(props),
+ props.result.rows.map((r) => ({ ...r }))
+ );
+
+ if (r.getRowsCount() >= 1000) {
+ r.gutterColumnWidth = 50;
+ }
+
+ if (r.getRowsCount() >= 10000) {
+ r.gutterColumnWidth = 60;
+ }
+
+ return r;
+}
diff --git a/src/components/gui/table-result/render-cell.tsx b/src/components/gui/table-result/render-cell.tsx
index 464f7fea..b41b04bd 100644
--- a/src/components/gui/table-result/render-cell.tsx
+++ b/src/components/gui/table-result/render-cell.tsx
@@ -7,6 +7,7 @@ import GenericCell from "../table-cell/generic-cell";
import NumberCell from "../table-cell/number-cell";
import TextCell from "../table-cell/text-cell";
import { OptimizeTableCellRenderProps } from "../table-optimized";
+import { TableHeaderMetadata } from "./type";
function detectTextEditorType(
value: DatabaseValue
@@ -47,7 +48,7 @@ export default function tableResultCellRenderer({
state,
header,
isFocus,
-}: OptimizeTableCellRenderProps) {
+}: OptimizeTableCellRenderProps) {
const editMode = isFocus && state.isInEditMode();
const value = state.getValue(y, x);
const valueType = determineCellType(value);
diff --git a/src/components/gui/table-optimized/table-state-actions.ts b/src/components/gui/table-result/table-state-actions.ts
similarity index 80%
rename from src/components/gui/table-optimized/table-state-actions.ts
rename to src/components/gui/table-result/table-state-actions.ts
index a6119a74..dd66cef2 100644
--- a/src/components/gui/table-optimized/table-state-actions.ts
+++ b/src/components/gui/table-result/table-state-actions.ts
@@ -1,7 +1,8 @@
-import OptimizeTableState from "./optimize-table-state";
+import OptimizeTableState from "../table-optimized/optimize-table-state";
+import { TableHeaderMetadata } from "./type";
export default class TableStateActions {
- static duplicateRow(state: OptimizeTableState) {
+ static duplicateRow(state: OptimizeTableState) {
const rowIndex = state.getFocus()?.y;
if (!rowIndex) return;
@@ -21,7 +22,9 @@ export default class TableStateActions {
}
}
- static duplicateRowWithoutKey(state: OptimizeTableState) {
+ static duplicateRowWithoutKey(
+ state: OptimizeTableState
+ ) {
const rowIndex = state.getFocus()?.y;
if (!rowIndex) return;
diff --git a/src/components/gui/table-result/type.tsx b/src/components/gui/table-result/type.tsx
new file mode 100644
index 00000000..f7b2edfa
--- /dev/null
+++ b/src/components/gui/table-result/type.tsx
@@ -0,0 +1,25 @@
+import { DatabaseTableColumn } from "@/drivers/base-driver";
+import { ColumnType } from "@outerbase/sdk-transform";
+
+export interface TableHeaderMetadata {
+ from?: {
+ schema: string;
+ table: string;
+ column: string;
+ };
+
+ // Primary key
+ isPrimaryKey: boolean;
+
+ // Foreign key reference
+ referenceTo?: {
+ schema: string;
+ table: string;
+ column: string;
+ };
+
+ type?: ColumnType;
+ originalType?: string;
+
+ columnSchema?: DatabaseTableColumn;
+}
diff --git a/src/components/gui/tabs-result/query-result-tab.tsx b/src/components/gui/tabs-result/query-result-tab.tsx
index 6f6df7c6..d7150a5b 100644
--- a/src/components/gui/tabs-result/query-result-tab.tsx
+++ b/src/components/gui/tabs-result/query-result-tab.tsx
@@ -6,7 +6,7 @@ import AggregateResultButton from "../aggregate-result/aggregate-result-button";
import ExportResultButton from "../export/export-result-button";
import ResultTable from "../query-result-table";
import ResultStats from "../result-stat";
-import OptimizeTableState from "../table-optimized/optimize-table-state";
+import { createTableStateFromResult } from "../table-result/helper";
export default function QueryResult({
result,
@@ -22,7 +22,7 @@ export default function QueryResult({
const [cachedSchemas] = useState(schema);
const data = useMemo(() => {
- const state = OptimizeTableState.createFromResult({
+ const state = createTableStateFromResult({
driver: databaseDriver,
result: result.result,
schemas: cachedSchemas,
diff --git a/src/components/gui/tabs/schema-editor-tab.tsx b/src/components/gui/tabs/schema-editor-tab.tsx
index 78c3636e..0a3a8a74 100644
--- a/src/components/gui/tabs/schema-editor-tab.tsx
+++ b/src/components/gui/tabs/schema-editor-tab.tsx
@@ -14,10 +14,7 @@ interface SchemaEditorTabProps {
}
const EMPTY_SCHEMA: DatabaseTableSchemaChange = {
- name: {
- old: "",
- new: "",
- },
+ name: { old: "", new: "" },
columns: [],
constraints: [],
createScript: "",
@@ -66,6 +63,7 @@ export default function SchemaEditorTab({
const onDiscard = useCallback(() => {
setSchema((prev) => {
return {
+ schemaName: prev.schemaName,
name: { ...prev.name, new: prev.name.old },
columns: prev.columns
.map((col) => ({
diff --git a/src/components/gui/tabs/table-data-tab.tsx b/src/components/gui/tabs/table-data-tab.tsx
index b3aa1235..e1d546fb 100644
--- a/src/components/gui/tabs/table-data-tab.tsx
+++ b/src/components/gui/tabs/table-data-tab.tsx
@@ -36,6 +36,8 @@ import OpacityLoading from "../loading-opacity";
import ResultStats from "../result-stat";
import OptimizeTableState from "../table-optimized/optimize-table-state";
import useTableResultColumnFilter from "../table-result/filter-column";
+import { createTableStateFromResult } from "../table-result/helper";
+import { TableHeaderMetadata } from "../table-result/type";
import { Toolbar } from "../toolbar";
import { useCurrentTab } from "../windows-tab";
@@ -55,7 +57,7 @@ export default function TableDataWindow({
const [executeError, setExecuteError] = useState(null);
const [loading, setLoading] = useState(false);
- const [data, setData] = useState();
+ const [data, setData] = useState>();
const [tableSchema, setTableSchema] = useState();
const [stat, setStat] = useState();
const [sortColumns, setSortColumns] = useState([]);
@@ -92,7 +94,7 @@ export default function TableDataWindow({
orderBy: sortColumns,
});
- const tableState = OptimizeTableState.createFromResult({
+ const tableState = createTableStateFromResult({
driver: databaseDriver,
result: dataResult,
tableSchema: schemaResult,
@@ -161,7 +163,7 @@ export default function TableDataWindow({
const onDiscard = useCallback(() => {
if (data) {
- data.disardAllChange();
+ data.discardAllChange();
}
}, [data]);
@@ -352,7 +354,10 @@ export default function TableDataWindow({
onChange={(e) => setLimit(e.currentTarget.value)}
onBlur={(e) => {
try {
- const finalValue = parseInt(e.currentTarget.value);
+ const finalValue = Math.max(
+ 0,
+ parseInt(e.currentTarget.value)
+ );
if (finalValue !== finalLimit) {
setFinalLimit(finalValue);
}
@@ -375,10 +380,14 @@ export default function TableDataWindow({
onChange={(e) => setOffset(e.currentTarget.value)}
onBlur={(e) => {
try {
- const finalValue = parseInt(e.currentTarget.value);
+ const finalValue = Math.max(
+ 0,
+ parseInt(e.currentTarget.value)
+ );
if (finalValue !== finalOffset) {
setFinalOffset(finalValue);
}
+ setOffset(finalValue.toString());
} catch (e) {
setOffset(finalOffset.toString());
}
diff --git a/src/core/extension-manager.tsx b/src/core/extension-manager.tsx
index e3fa7280..ff7f25c1 100644
--- a/src/core/extension-manager.tsx
+++ b/src/core/extension-manager.tsx
@@ -1,5 +1,6 @@
import { OptimizeTableHeaderProps } from "@/components/gui/table-optimized";
import OptimizeTableState from "@/components/gui/table-optimized/optimize-table-state";
+import { TableHeaderMetadata } from "@/components/gui/table-result/type";
import { DatabaseSchemaItem, DatabaseSchemas } from "@/drivers/base-driver";
import { ReactElement } from "react";
import { IStudioExtension } from "./extension-base";
@@ -29,8 +30,8 @@ type CreateResourceMenuHandler = (
) => StudioExtensionMenuItem | undefined;
type QueryHeaderResultMenuHandler = (
- header: OptimizeTableHeaderProps,
- state: OptimizeTableState
+ header: OptimizeTableHeaderProps,
+ state: OptimizeTableState
) => StudioExtensionMenuItem | undefined;
type AfterFetchSchemaHandler = (schema: DatabaseSchemas) => void;
@@ -123,8 +124,8 @@ export class StudioExtensionManager extends StudioExtensionContext {
}
getQueryHeaderContextMenu(
- header: OptimizeTableHeaderProps,
- state: OptimizeTableState
+ header: OptimizeTableHeaderProps,
+ state: OptimizeTableState
) {
return this.queryResultHeaderContextMenu
.map((handler) => handler(header, state))
diff --git a/src/drivers/board-storage/local.ts b/src/drivers/board-storage/local.ts
index 4570f1dd..a64e9001 100644
--- a/src/drivers/board-storage/local.ts
+++ b/src/drivers/board-storage/local.ts
@@ -16,7 +16,15 @@ export default class LocalBoardStorage implements IBoardStorageDriver {
id,
};
- this.board.charts.push(data);
+ // Handle potentially undefined charts property
+ // This is a temporary fix until we can address the type inconsistency
+ // where charts is sometimes an array and sometimes undefined
+ if (Array.isArray(this.board.charts)) {
+ this.board.charts.push(data);
+ } else {
+ this.board.charts = [data];
+ }
+
this.board.updated_at = now;
localDb.board.put({ id: this.board.id, content: this.board });
diff --git a/src/drivers/sqlite/sql-parse-constraint.test.ts b/src/drivers/sqlite/sql-parse-constraint.test.ts
new file mode 100644
index 00000000..bfac16cd
--- /dev/null
+++ b/src/drivers/sqlite/sql-parse-constraint.test.ts
@@ -0,0 +1,121 @@
+import type { DatabaseTableColumnConstraint } from "@/drivers/base-driver";
+import { tokenizeSql } from "@outerbase/sdk-transform";
+import { CursorV2, parseColumnConstraint } from "./sql-parse-table";
+
+// Parse column constraint
+function pcc(sql: string) {
+ return parseColumnConstraint(
+ "main",
+ new CursorV2(tokenizeSql(sql, "sqlite"))
+ );
+}
+
+describe("parse column constraint", () => {
+ test("constraint this_is_primary_key primary key autoincrement", () => {
+ expect(
+ pcc("constraint this_is_primary_key primary key autoincrement")
+ ).toEqual({
+ name: "this_is_primary_key",
+ primaryKey: true,
+ autoIncrement: true,
+ } as DatabaseTableColumnConstraint);
+ });
+ test("primary key with multiple columns", () => {
+ expect(pcc("primary key(first_name, last_name)")).toEqual({
+ primaryKey: true,
+ autoIncrement: false,
+ primaryColumns: ["first_name", "last_name"],
+ } as DatabaseTableColumnConstraint);
+ });
+
+ test("primary key with conflict clause and not null", () => {
+ expect(pcc("primary key on conflict rollback not null")).toEqual({
+ primaryKey: true,
+ autoIncrement: false,
+ primaryKeyConflict: "ROLLBACK",
+ notNull: true,
+ } as DatabaseTableColumnConstraint);
+ });
+
+ test("not null before primary key with conflict clause", () => {
+ expect(pcc("not null primary key on conflict rollback")).toEqual({
+ primaryKey: true,
+ autoIncrement: false,
+ primaryKeyConflict: "ROLLBACK",
+ notNull: true,
+ } as DatabaseTableColumnConstraint);
+ });
+
+ test("unique with conflict clause", () => {
+ expect(pcc("unique on conflict rollback")).toEqual({
+ unique: true,
+ uniqueConflict: "ROLLBACK",
+ } as DatabaseTableColumnConstraint);
+ });
+
+ test("default with string value", () => {
+ expect(pcc(`default 'Visal'`)).toEqual({
+ defaultValue: "Visal",
+ } as DatabaseTableColumnConstraint);
+ });
+
+ test("default with negative number", () => {
+ expect(pcc(`default -5`)).toEqual({
+ defaultValue: -5,
+ } as DatabaseTableColumnConstraint);
+ });
+
+ test("default with positive decimal", () => {
+ expect(pcc(`default +5.5`)).toEqual({
+ defaultValue: 5.5,
+ } as DatabaseTableColumnConstraint);
+ });
+
+ test("default with decimal", () => {
+ expect(pcc(`default 5.5`)).toEqual({
+ defaultValue: 5.5,
+ } as DatabaseTableColumnConstraint);
+ });
+
+ test("default with function", () => {
+ expect(pcc(`default current_timestamp`)).toEqual({
+ defaultExpression: "current_timestamp",
+ } as DatabaseTableColumnConstraint);
+ });
+
+ test("default with expression", () => {
+ expect(pcc(`default (round(julianday('now')))`)).toEqual({
+ defaultExpression: `round(julianday('now'))`,
+ } as DatabaseTableColumnConstraint);
+ });
+
+ test("foreign key with references", () => {
+ expect(
+ pcc(`foreign key ("user_id") references "users" on delete cascade ("id")`)
+ ).toEqual({
+ foreignKey: {
+ foreignSchemaName: "main",
+ columns: ["user_id"],
+ foreignTableName: "users",
+ foreignColumns: ["id"],
+ },
+ } as DatabaseTableColumnConstraint);
+ });
+
+ test("references shorthand", () => {
+ expect(pcc(`references "users" on delete cascade ("id")`)).toEqual({
+ foreignKey: {
+ foreignSchemaName: "main",
+ foreignTableName: "users",
+ foreignColumns: ["id"],
+ },
+ } as DatabaseTableColumnConstraint);
+ });
+
+ test("generated column", () => {
+ expect(pcc(`generated always as (price * qty) virtual`)).toEqual({
+ generatedExpression: "price * qty",
+ generatedType: "VIRTUAL",
+ } as DatabaseTableColumnConstraint);
+ });
+});
diff --git a/src/drivers/sqlite/sql-parse-table.test.ts b/src/drivers/sqlite/sql-parse-table.test.ts
index 11e680af..c193905c 100644
--- a/src/drivers/sqlite/sql-parse-table.test.ts
+++ b/src/drivers/sqlite/sql-parse-table.test.ts
@@ -1,107 +1,15 @@
-import type {
- DatabaseTableColumnConstraint,
- DatabaseTableSchema,
-} from "@/drivers/base-driver";
-import {
- buildSyntaxCursor,
- parseColumnConstraint,
- parseCreateTableScript,
-} from "./sql-parse-table";
+import type { DatabaseTableSchema } from "@/drivers/base-driver";
+import { parseCreateTableScript } from "./sql-parse-table";
// Parse column constraint
-function pcc(sql: string) {
- return parseColumnConstraint("main", buildSyntaxCursor(sql));
-}
function p(sql: string) {
return parseCreateTableScript("main", sql);
}
-it("parse column constraint", () => {
- expect(
- pcc("constraint this_is_primary_key primary key autoincrement")
- ).toEqual({
- name: "this_is_primary_key",
- primaryKey: true,
- autoIncrement: true,
- } as DatabaseTableColumnConstraint);
-
- expect(pcc("primary key(first_name, last_name)")).toEqual({
- primaryKey: true,
- autoIncrement: false,
- primaryColumns: ["first_name", "last_name"],
- } as DatabaseTableColumnConstraint);
-
- expect(pcc("primary key on conflict rollback not null")).toEqual({
- primaryKey: true,
- autoIncrement: false,
- primaryKeyConflict: "ROLLBACK",
- notNull: true,
- } as DatabaseTableColumnConstraint);
-
- expect(pcc("not null primary key on conflict rollback")).toEqual({
- primaryKey: true,
- autoIncrement: false,
- primaryKeyConflict: "ROLLBACK",
- notNull: true,
- } as DatabaseTableColumnConstraint);
-
- expect(pcc("unique on conflict rollback")).toEqual({
- unique: true,
- uniqueConflict: "ROLLBACK",
- } as DatabaseTableColumnConstraint);
-
- expect(pcc(`default 'Visal'`)).toEqual({
- defaultValue: "Visal",
- } as DatabaseTableColumnConstraint);
-
- expect(pcc(`default -5`)).toEqual({
- defaultValue: -5,
- } as DatabaseTableColumnConstraint);
-
- expect(pcc(`default +5.5`)).toEqual({
- defaultValue: 5.5,
- } as DatabaseTableColumnConstraint);
-
- expect(pcc(`default 5.5`)).toEqual({
- defaultValue: 5.5,
- } as DatabaseTableColumnConstraint);
-
- expect(pcc(`default current_timestamp`)).toEqual({
- defaultExpression: "current_timestamp",
- } as DatabaseTableColumnConstraint);
-
- expect(pcc(`default (round(julianday('now'))`)).toEqual({
- defaultExpression: `(round(julianday('now'))`,
- } as DatabaseTableColumnConstraint);
-
- expect(
- pcc(`foreign key ("user_id") references "users" on delete cascade ("id")`)
- ).toEqual({
- foreignKey: {
- foreignSchemaName: "main",
- columns: ["user_id"],
- foreignTableName: "users",
- foreignColumns: ["id"],
- },
- } as DatabaseTableColumnConstraint);
-
- expect(pcc(`references "users" on delete cascade ("id")`)).toEqual({
- foreignKey: {
- foreignSchemaName: "main",
- foreignTableName: "users",
- foreignColumns: ["id"],
- },
- } as DatabaseTableColumnConstraint);
-
- expect(pcc(`generated always as (price * qty) virtual`)).toEqual({
- generatedExpression: "(price * qty)",
- generatedType: "VIRTUAL",
- } as DatabaseTableColumnConstraint);
-});
-
-it("parse create table", () => {
- const sql = `create table "invoice_detail"(
+describe("parse create table", () => {
+ test("parse simple create table", () => {
+ const sql = `create table "invoice_detail"(
id integer primary key autoincrement,
product_id integer references product(id),
price real not null,
@@ -110,62 +18,62 @@ it("parse create table", () => {
total real generated always as (price * qty) virtual
);`;
- expect(p(sql)).toEqual({
- tableName: "invoice_detail",
- pk: ["id"],
- autoIncrement: true,
- constraints: [],
- schemaName: "main",
- columns: [
- {
- name: "id",
- type: "integer",
- pk: true,
- constraint: {
- primaryKey: true,
- autoIncrement: true,
+ expect(p(sql)).toEqual({
+ tableName: "invoice_detail",
+ pk: ["id"],
+ autoIncrement: true,
+ constraints: [],
+ schemaName: "main",
+ columns: [
+ {
+ name: "id",
+ type: "integer",
+ pk: true,
+ constraint: {
+ primaryKey: true,
+ autoIncrement: true,
+ },
},
- },
- {
- name: "product_id",
- type: "integer",
- constraint: {
- foreignKey: {
- foreignSchemaName: "main",
- foreignTableName: "product",
- foreignColumns: ["id"],
+ {
+ name: "product_id",
+ type: "integer",
+ constraint: {
+ foreignKey: {
+ foreignSchemaName: "main",
+ foreignTableName: "product",
+ foreignColumns: ["id"],
+ },
},
},
- },
- {
- name: "price",
- type: "real",
- constraint: {
- notNull: true,
+ {
+ name: "price",
+ type: "real",
+ constraint: {
+ notNull: true,
+ },
},
- },
- {
- name: "qty",
- type: "real",
- },
- {
- name: "note",
- type: "varchar(255)",
- },
- {
- name: "total",
- type: "real",
- constraint: {
- generatedExpression: "(price * qty)",
- generatedType: "VIRTUAL",
+ {
+ name: "qty",
+ type: "real",
},
- },
- ],
- } as DatabaseTableSchema);
-});
+ {
+ name: "note",
+ type: "varchar(255)",
+ },
+ {
+ name: "total",
+ type: "real",
+ constraint: {
+ generatedExpression: "price * qty",
+ generatedType: "VIRTUAL",
+ },
+ },
+ ],
+ } as DatabaseTableSchema);
+ });
-it("parse create table with table constraints", () => {
- const sql = `create table "users"(
+ it("parse create table with table constraints", () => {
+ const sql = `create table "users"(
first_name varchar,
last_name varchar,
category_id integer,
@@ -173,117 +81,117 @@ it("parse create table with table constraints", () => {
foreign key(category_id) references category(id)
);`;
- expect(p(sql)).toEqual({
- tableName: "users",
- schemaName: "main",
- pk: ["first_name", "last_name"],
- autoIncrement: false,
- constraints: [
- {
- primaryKey: true,
- autoIncrement: false,
- primaryColumns: ["first_name", "last_name"],
- },
- {
- foreignKey: {
- foreignSchemaName: "main",
- columns: ["category_id"],
- foreignColumns: ["id"],
- foreignTableName: "category",
+ expect(p(sql)).toEqual({
+ tableName: "users",
+ schemaName: "main",
+ pk: ["first_name", "last_name"],
+ autoIncrement: false,
+ constraints: [
+ {
+ primaryKey: true,
+ autoIncrement: false,
+ primaryColumns: ["first_name", "last_name"],
},
- },
- ],
- columns: [
- {
- name: "first_name",
- type: "varchar",
- pk: true,
- },
- {
- name: "last_name",
- type: "varchar",
- pk: true,
- },
- {
- name: "category_id",
- type: "integer",
- },
- ],
- } as DatabaseTableSchema);
-});
+ {
+ foreignKey: {
+ foreignSchemaName: "main",
+ columns: ["category_id"],
+ foreignColumns: ["id"],
+ foreignTableName: "category",
+ },
+ },
+ ],
+ columns: [
+ {
+ name: "first_name",
+ type: "varchar",
+ pk: true,
+ },
+ {
+ name: "last_name",
+ type: "varchar",
+ pk: true,
+ },
+ {
+ name: "category_id",
+ type: "integer",
+ },
+ ],
+ } as DatabaseTableSchema);
+ });
-it("parse fts5 virtual table", () => {
- const sql = `create virtual table name_fts using fts5(name, tokenize='trigram');`;
- expect(p(sql)).toEqual({
- tableName: "name_fts",
- schemaName: "main",
- autoIncrement: false,
- pk: [],
- columns: [],
- constraints: [],
- fts5: {},
- } as DatabaseTableSchema);
-});
+ it("parse fts5 virtual table", () => {
+ const sql = `create virtual table name_fts using fts5(name, tokenize='trigram');`;
+ expect(p(sql)).toEqual({
+ tableName: "name_fts",
+ schemaName: "main",
+ autoIncrement: false,
+ pk: [],
+ columns: [],
+ constraints: [],
+ fts5: {},
+ } as DatabaseTableSchema);
+ });
-it("parse fts5 virtual table with external content", () => {
- const sql = `create virtual table name_fts using fts5(name, tokenize='trigram', content='student', content_rowid='id');`;
- expect(p(sql)).toEqual({
- tableName: "name_fts",
- schemaName: "main",
- autoIncrement: false,
- pk: [],
- columns: [],
- constraints: [],
- fts5: {
- content: "'student'",
- contentRowId: "'id'",
- },
- } as DatabaseTableSchema);
-});
+ it("parse fts5 virtual table with external content", () => {
+ const sql = `create virtual table name_fts using fts5(name, tokenize='trigram', content='student', content_rowid='id');`;
+ expect(p(sql)).toEqual({
+ tableName: "name_fts",
+ schemaName: "main",
+ autoIncrement: false,
+ pk: [],
+ columns: [],
+ constraints: [],
+ fts5: {
+ content: "'student'",
+ contentRowId: "'id'",
+ },
+ } as DatabaseTableSchema);
+ });
-it("parse without row id", () => {
- const sql = `create table students(name text) without rowid;`;
- expect(p(sql)).toEqual({
- tableName: "students",
- schemaName: "main",
- autoIncrement: false,
- pk: [],
- columns: [{ name: "name", type: "text" }],
- constraints: [],
- withoutRowId: true,
- } as DatabaseTableSchema);
-});
+ it("parse without row id", () => {
+ const sql = `create table students(name text) without rowid;`;
+ expect(p(sql)).toEqual({
+ tableName: "students",
+ schemaName: "main",
+ autoIncrement: false,
+ pk: [],
+ columns: [{ name: "name", type: "text" }],
+ constraints: [],
+ withoutRowId: true,
+ } as DatabaseTableSchema);
+ });
-it("parse strict table", () => {
- const sql = `create table students(name text) strict;`;
- expect(p(sql)).toEqual({
- tableName: "students",
- schemaName: "main",
- autoIncrement: false,
- pk: [],
- columns: [{ name: "name", type: "text" }],
- constraints: [],
- strict: true,
- } as DatabaseTableSchema);
-});
+ it("parse strict table", () => {
+ const sql = `create table students(name text) strict;`;
+ expect(p(sql)).toEqual({
+ tableName: "students",
+ schemaName: "main",
+ autoIncrement: false,
+ pk: [],
+ columns: [{ name: "name", type: "text" }],
+ constraints: [],
+ strict: true,
+ } as DatabaseTableSchema);
+ });
-it("parse strict and without row id table", () => {
- const sql = `create table students(name text) strict, without rowid;`;
- expect(p(sql)).toEqual({
- tableName: "students",
- schemaName: "main",
- autoIncrement: false,
- pk: [],
- columns: [{ name: "name", type: "text" }],
- constraints: [],
- strict: true,
- withoutRowId: true,
- } as DatabaseTableSchema);
-});
+ it("parse strict and without row id table", () => {
+ const sql = `create table students(name text) strict, without rowid;`;
+ expect(p(sql)).toEqual({
+ tableName: "students",
+ schemaName: "main",
+ autoIncrement: false,
+ pk: [],
+ columns: [{ name: "name", type: "text" }],
+ constraints: [],
+ strict: true,
+ withoutRowId: true,
+ } as DatabaseTableSchema);
+ });
-// Regression test for https://github.com/outerbase/studio/issues/403
-it("parse table with foreign key and default", () => {
- const sql = `CREATE TABLE "suggestions"(
+ // Regression test for https://github.com/outerbase/studio/issues/403
+ it("parse table with foreign key and default", () => {
+ const sql = `CREATE TABLE "suggestions"(
"id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
"entry" INTEGER NOT NULL REFERENCES "entries"("id"),
"user" INTEGER NOT NULL REFERENCES "users"("id"),
@@ -291,60 +199,61 @@ it("parse table with foreign key and default", () => {
"updatedAt" INTEGER NOT NULL DEFAULT (UNIXEPOCH())
)`;
- expect(p(sql)).toEqual({
- tableName: "suggestions",
- schemaName: "main",
- autoIncrement: true,
- pk: ["id"],
- columns: [
- {
- name: "id",
- type: "INTEGER",
- pk: true,
- constraint: { notNull: true, primaryKey: true, autoIncrement: true },
- },
- {
- name: "entry",
- type: "INTEGER",
- constraint: {
- notNull: true,
- foreignKey: {
- foreignSchemaName: "main",
- foreignTableName: "entries",
- foreignColumns: ["id"],
+ expect(p(sql)).toEqual({
+ tableName: "suggestions",
+ schemaName: "main",
+ autoIncrement: true,
+ pk: ["id"],
+ columns: [
+ {
+ name: "id",
+ type: "INTEGER",
+ pk: true,
+ constraint: { notNull: true, primaryKey: true, autoIncrement: true },
+ },
+ {
+ name: "entry",
+ type: "INTEGER",
+ constraint: {
+ notNull: true,
+ foreignKey: {
+ foreignSchemaName: "main",
+ foreignTableName: "entries",
+ foreignColumns: ["id"],
+ },
},
},
- },
- {
- name: "user",
- type: "INTEGER",
- constraint: {
- notNull: true,
- foreignKey: {
- foreignSchemaName: "main",
- foreignTableName: "users",
- foreignColumns: ["id"],
+ {
+ name: "user",
+ type: "INTEGER",
+ constraint: {
+ notNull: true,
+ foreignKey: {
+ foreignSchemaName: "main",
+ foreignTableName: "users",
+ foreignColumns: ["id"],
+ },
},
},
- },
- {
- name: "scoreBy",
- type: "INTEGER",
- constraint: {
- foreignKey: {
- foreignSchemaName: "main",
- foreignTableName: "users",
- foreignColumns: ["id"],
+ {
+ name: "scoreBy",
+ type: "INTEGER",
+ constraint: {
+ foreignKey: {
+ foreignSchemaName: "main",
+ foreignTableName: "users",
+ foreignColumns: ["id"],
+ },
+ defaultExpression: "NULL",
},
- defaultExpression: "NULL",
},
- },
- {
- name: "updatedAt",
- type: "INTEGER",
- constraint: { notNull: true, defaultExpression: "(UNIXEPOCH())" },
- },
- ],
- constraints: [],
- } as DatabaseTableSchema);
+ {
+ name: "updatedAt",
+ type: "INTEGER",
+ constraint: { notNull: true, defaultExpression: "UNIXEPOCH()" },
+ },
+ ],
+ constraints: [],
+ } as DatabaseTableSchema);
+ });
});
diff --git a/src/drivers/sqlite/sql-parse-table.ts b/src/drivers/sqlite/sql-parse-table.ts
index a312e553..dea4335d 100644
--- a/src/drivers/sqlite/sql-parse-table.ts
+++ b/src/drivers/sqlite/sql-parse-table.ts
@@ -6,125 +6,154 @@ import type {
DatabaseTableSchema,
SqlOrder,
} from "@/drivers/base-driver";
-import { sqliteDialect } from "@/drivers/sqlite/sqlite-dialect";
-import type { SyntaxNode, TreeCursor } from "@lezer/common";
+import { Token, tokenizeSql } from "@outerbase/sdk-transform";
import { unescapeIdentity } from "./sql-helper";
-export class Cursor {
- protected ptr: SyntaxNode | null;
- protected sql = "";
+// This class represents a new cursor implementation for SQL parsing that operates on an array of strings
+// rather than an Abstract Syntax Tree (AST). This approach is designed to reduce dependency on
+// code-mirror's AST which may be subject to change, providing more stability for our parsing logic.
+export class CursorV2 {
+ private ptr: number = 0;
- constructor(ptr: TreeCursor, sql: string) {
- this.ptr = ptr.node;
- this.sql = sql;
- }
+ constructor(private tokens: Token[]) {
+ // Trim whitespace tokens from the beginning and end
+ while (this.tokens.length > 0 && this.tokens[0].type === "WHITESPACE") {
+ this.tokens.shift();
+ }
- expectKeyword(keyword: string) {
- const errorMessage = `Expect ${keyword} keywords, but not found`;
+ while (
+ this.tokens.length > 0 &&
+ this.tokens[this.tokens.length - 1].type === "WHITESPACE"
+ ) {
+ this.tokens.pop();
+ }
- if (!this.ptr) throw new Error(errorMessage);
- if (!this.matchKeyword(keyword)) throw new Error(errorMessage);
+ this.tokens = tokens;
+ }
- this.ptr = this.ptr.nextSibling;
+ getPointer() {
+ return this.ptr;
}
- expectKeywordOptional(keyword: string) {
- if (this.ptr) {
- if (this.matchKeyword(keyword)) {
- this.next();
- }
- }
+ toStringRange(start: number, end: number) {
+ return this.tokens
+ .slice(start, end)
+ .map((t) => t.value)
+ .join("");
}
- expectKeywordsOptional(keywords: string[]) {
- if (keywords.length === 0) return;
- if (this.matchKeyword(keywords[0] ?? "")) {
- this.next();
- for (const k of keywords.slice(1)) {
- this.expectKeyword(k);
- }
- }
+ read(): string {
+ if (this.end()) return "";
+ return this.tokens[this.ptr].value;
}
- consumeIdentifier() {
- if (this.ptr) {
- const id = unescapeIdentity(this.read());
- this.next();
- return id;
+ consumeBlock(): string {
+ if (this.match("(")) {
+ return this.consumeParen().toString();
+ } else {
+ return this.consume();
}
- return "";
}
- readKeyword(): string {
- if (this.ptr && this.ptr.type.name === "Keyword") {
- const keyword = this.read();
- this.next();
- return keyword;
+ currentType() {
+ return this.tokens[this.ptr].type;
+ }
+
+ consumeParen(): CursorV2 {
+ if (this.read() !== "(") throw new Error("Expecting (");
+
+ const start = this.ptr + 1;
+ let counter = 1;
+
+ // Find the matching closing paren
+ while (counter > 0) {
+ if (!this.next()) throw new Error("Expecting closing paren");
+ if (this.read() === "(") counter++;
+ if (this.read() === ")") counter--;
}
- return "";
+
+ const newCursor = new CursorV2(this.tokens.slice(start, this.ptr));
+ this.next();
+
+ return newCursor;
}
- next() {
- this.ptr = this.ptr?.nextSibling ?? null;
+ consume() {
+ const value = this.read();
+ this.next();
+ return value;
}
- matchKeyword(keyword: string) {
- if (this.ptr && this.ptr.type.name !== "Keyword") return false;
- return this.read().toUpperCase() === keyword.toUpperCase();
+ consumeIdentifier() {
+ const value = unescapeIdentity(this.read());
+ this.next();
+ return value;
}
- matchKeywords(keywords: string[]) {
- if (this.ptr && this.ptr.type.name !== "Keyword") return false;
- const currentValue = this.read().toUpperCase();
- return keywords.some((keyword) => keyword.toUpperCase() === currentValue);
+ expectToken(value: string) {
+ if (!this.match(value)) throw new Error(`Expecting ${value}`);
+ this.next();
}
- match(keyword: string) {
- if (!this.ptr) return false;
- return this.read().toUpperCase() === keyword.toUpperCase();
+ expectTokenOptional(value: string) {
+ if (this.match(value)) this.next();
}
- read(): string {
- if (this.ptr?.node) {
- return this.sql.substring(this.ptr.node.from, this.ptr.node.to);
+ expectTokensOptional(values: string[]) {
+ if (values.length === 0) return;
+ if (this.read() === values[0]) {
+ this.next();
+ for (const v of values.slice(1)) {
+ this.expectToken(v);
+ }
}
- return "";
}
- node(): SyntaxNode | undefined {
- return this.ptr?.node;
+ expectTokens(values: string[]) {
+ for (const v of values) {
+ this.expectToken(v);
+ }
}
- type(): string | undefined {
- return this.ptr?.type.name;
+ /**
+ * Next will skip to valid non-whitespace token
+ * @returns true if there is a next token, false otherwise
+ */
+ next() {
+ for (this.ptr = this.ptr + 1; this.ptr < this.tokens.length; this.ptr++) {
+ if (this.currentType() !== "WHITESPACE") {
+ return true;
+ }
+ }
+
+ return false;
}
- enterParens(): Cursor | null {
- if (this.ptr?.firstChild) {
- if (this.ptr.firstChild.name !== "(") return null;
- if (!this.ptr.firstChild.nextSibling) return null;
- return new Cursor(this.ptr.firstChild.nextSibling.cursor(), this.sql);
- }
+ match(value: string) {
+ if (this.end()) return false;
+ return this.read().toLowerCase() === value.toLowerCase();
+ }
- return null;
+ matchTokens(values: string[]) {
+ return values.some((v) => this.read().toLowerCase() === v.toLowerCase());
}
end() {
- return this.ptr === null;
+ return this.ptr >= this.tokens.length;
}
-}
-export function buildSyntaxCursor(sql: string): Cursor {
- const r = sqliteDialect.language.parser.parse(sql).cursor();
- r.firstChild();
- r.firstChild();
+ toString() {
+ return this.tokens.map((t) => t.value).join("");
+ }
- return new Cursor(r, sql);
+ toStringWithParen() {
+ return "(" + this.toString() + ")";
+ }
}
function parseColumnDef(
schemaName: string,
- cursor: Cursor
+ cursor: CursorV2
): DatabaseTableColumn | null {
const columnName = cursor.consumeIdentifier();
if (!columnName) return null;
@@ -134,9 +163,8 @@ function parseColumnDef(
// Handle case such as VARCHAR(255) where we need to read
// something inside the parens
- if (cursor.type() === "Parens") {
- dataType += cursor.read();
- cursor.next();
+ if (cursor.match("(")) {
+ dataType += cursor.consumeParen().toStringWithParen();
}
const constraint = parseColumnConstraint(schemaName, cursor);
@@ -150,12 +178,12 @@ function parseColumnDef(
}
function parseConstraintConflict(
- cursor: Cursor
+ cursor: CursorV2
): DatabaseColumnConflict | undefined {
- if (!cursor.matchKeyword("ON")) return;
+ if (!cursor.match("ON")) return;
cursor.next();
- if (!cursor.matchKeyword("CONFLICT")) return;
+ if (!cursor.match("CONFLICT")) return;
cursor.next();
if (!cursor.end()) {
@@ -167,7 +195,7 @@ function parseConstraintConflict(
return;
}
-export function parseColumnList(columnPtr: Cursor) {
+export function parseColumnList(columnPtr: CursorV2) {
const columns: string[] = [];
while (!columnPtr.end()) {
@@ -182,44 +210,41 @@ export function parseColumnList(columnPtr: Cursor) {
export function parseColumnConstraint(
schemaName: string,
- cursor: Cursor
+ cursor: CursorV2
): DatabaseTableColumnConstraint | undefined {
- if (cursor.matchKeyword("CONSTRAINT")) {
+ if (cursor.match("CONSTRAINT")) {
cursor.next();
- const constraintName = cursor.consumeIdentifier();
+ const constraintName = cursor.consume();
return {
...parseColumnConstraint(schemaName, cursor),
name: constraintName,
};
- } else if (cursor.matchKeyword("PRIMARY")) {
+ } else if (cursor.match("PRIMARY")) {
let primaryKeyOrder: SqlOrder | undefined;
let primaryColumns: string[] | undefined;
let autoIncrement = false;
cursor.next();
- if (!cursor.matchKeyword("KEY"))
- throw new Error("PRIMARY must follow by KEY");
+ if (!cursor.match("KEY")) throw new Error("PRIMARY must follow by KEY");
cursor.next();
- const parens = cursor.enterParens();
- if (parens) {
- primaryColumns = parseColumnList(parens);
- cursor.next();
+ if (cursor.match("(")) {
+ primaryColumns = parseColumnList(cursor.consumeParen());
}
- if (cursor.matchKeyword("ASC")) {
+ if (cursor.match("ASC")) {
primaryKeyOrder = "ASC";
cursor.next();
- } else if (cursor.matchKeyword("DESC")) {
+ } else if (cursor.match("DESC")) {
primaryKeyOrder = "DESC";
cursor.next();
}
const conflict = parseConstraintConflict(cursor);
- if (cursor.matchKeyword("AUTOINCREMENT")) {
+ if (cursor.match("AUTOINCREMENT")) {
autoIncrement = true;
cursor.next();
}
@@ -232,7 +257,7 @@ export function parseColumnConstraint(
primaryKeyConflict: conflict,
...parseColumnConstraint(schemaName, cursor),
};
- } else if (cursor.matchKeyword("NOT")) {
+ } else if (cursor.match("NOT")) {
cursor.next();
if (!cursor.match("NULL")) throw new Error("NOT should follow by NULL");
cursor.next();
@@ -243,15 +268,13 @@ export function parseColumnConstraint(
notNullConflict: conflict,
...parseColumnConstraint(schemaName, cursor),
};
- } else if (cursor.matchKeyword("UNIQUE")) {
+ } else if (cursor.match("UNIQUE")) {
let uniqueColumns: string[] | undefined;
cursor.next();
- const parens = cursor.enterParens();
- if (parens) {
- uniqueColumns = parseColumnList(parens);
- cursor.next();
+ if (cursor.read() === "(") {
+ uniqueColumns = parseColumnList(cursor.consumeParen());
}
const conflict = parseConstraintConflict(cursor);
@@ -262,16 +285,16 @@ export function parseColumnConstraint(
uniqueColumns,
...parseColumnConstraint(schemaName, cursor),
};
- } else if (cursor.matchKeyword("DEFAULT")) {
+ } else if (cursor.match("DEFAULT")) {
let defaultValue: unknown;
let defaultExpression: string | undefined;
cursor.next();
- if (cursor.type() === "String") {
+ if (cursor.currentType() === "STRING") {
defaultValue = cursor.read().slice(1, -1);
cursor.next();
- } else if (cursor.type() === "Operator") {
+ } else if (cursor.currentType() === "OPERATOR") {
if (cursor.match("+")) {
cursor.next();
defaultValue = Number(cursor.read());
@@ -281,12 +304,11 @@ export function parseColumnConstraint(
defaultValue = -Number(cursor.read());
cursor.next();
}
- } else if (cursor.type() === "Number") {
+ } else if (cursor.currentType() === "NUMBER") {
defaultValue = Number(cursor.read());
cursor.next();
- } else if (cursor.type() === "Parens") {
- defaultExpression = cursor.read();
- cursor.next();
+ } else if (cursor.match("(")) {
+ defaultExpression = cursor.consumeParen().toString();
} else if (
cursor.match("current_timestamp") ||
cursor.match("current_time") ||
@@ -304,7 +326,7 @@ export function parseColumnConstraint(
defaultExpression,
...parseColumnConstraint(schemaName, cursor),
};
- } else if (cursor.matchKeyword("CHECK")) {
+ } else if (cursor.match("CHECK")) {
cursor.next();
const expr = cursor.read();
@@ -314,7 +336,7 @@ export function parseColumnConstraint(
checkExpression: expr,
...parseColumnConstraint(schemaName, cursor),
};
- } else if (cursor.matchKeyword("COLLATE")) {
+ } else if (cursor.match("COLLATE")) {
cursor.next();
const collationName = cursor.read();
@@ -324,18 +346,15 @@ export function parseColumnConstraint(
collate: collationName,
...parseColumnConstraint(schemaName, cursor),
};
- } else if (cursor.matchKeyword("FOREIGN")) {
+ } else if (cursor.match("FOREIGN")) {
cursor.next();
if (!cursor.match("KEY")) throw new Error("FOREIGN should follow by KEY");
cursor.next();
- const parens = cursor.enterParens();
-
- if (!parens) throw new Error("FOREIGN KEY should follow by column list");
-
+ const parens = cursor.consumeParen();
const columns = parseColumnList(parens);
- cursor.next();
+
const refConstraint = parseColumnConstraint(schemaName, cursor);
return {
@@ -346,7 +365,7 @@ export function parseColumnConstraint(
columns,
},
};
- } else if (cursor.matchKeyword("REFERENCES")) {
+ } else if (cursor.match("REFERENCES")) {
cursor.next();
const foreignTableName = cursor.consumeIdentifier();
let foreignColumns: string[] = [];
@@ -355,14 +374,12 @@ export function parseColumnConstraint(
// We may visit more rule in the future, but at the moment
// it is too complex to handle all the rules.
// We will just grab foreign key column first
- while (!cursor.end() && cursor.type() !== "Parens" && !cursor.match(",")) {
+ while (!cursor.end() && !cursor.match("(") && !cursor.match(",")) {
cursor.next();
}
- const columnPtr = cursor.enterParens();
-
- if (columnPtr) {
- foreignColumns = parseColumnList(columnPtr);
+ if (cursor.match("(")) {
+ foreignColumns = parseColumnList(cursor.consumeParen());
}
return {
@@ -383,12 +400,10 @@ export function parseColumnConstraint(
throw new Error("GENERATED ALWAYS should follow by AS");
cursor.next();
- const expr = cursor.read();
+ const expr = cursor.consumeBlock();
cursor.next();
- const virtualColumnType = cursor.matchKeyword("STORED")
- ? "STORED"
- : "VIRTUAL";
+ const virtualColumnType = cursor.match("STORED") ? "STORED" : "VIRTUAL";
return {
generatedType: virtualColumnType,
@@ -402,7 +417,7 @@ export function parseColumnConstraint(
function parseTableDefinition(
schemaName: string,
- cursor: Cursor
+ cursor: CursorV2
): {
columns: DatabaseTableColumn[];
constraints: DatabaseTableColumnConstraint[];
@@ -415,7 +430,7 @@ function parseTableDefinition(
moveNext = false;
if (
- cursor.matchKeywords([
+ cursor.matchTokens([
"CONSTRAINT",
"PRIMARY",
"UNIQUE",
@@ -444,6 +459,8 @@ function parseTableDefinition(
cursor.next();
}
+ // console.log(columns, constraints);
+
for (const constraint of constraints) {
if (constraint.primaryKey && constraint.primaryColumns) {
for (const pkColumn of constraint.primaryColumns) {
@@ -468,7 +485,7 @@ function parseTableDefinition(
return { columns, constraints };
}
-function parseFTS5(cursor: Cursor | null): DatabaseTableFts5 {
+function parseFTS5(cursor: CursorV2): DatabaseTableFts5 {
if (!cursor) return {};
let content: string | undefined;
@@ -505,7 +522,7 @@ function parseFTS5(cursor: Cursor | null): DatabaseTableFts5 {
};
}
-function parseTableOption(cursor: Cursor):
+function parseTableOption(cursor: CursorV2):
| {
strict?: boolean;
withoutRowId?: boolean;
@@ -539,19 +556,15 @@ export function parseCreateTableScript(
schemaName: string,
sql: string
): DatabaseTableSchema {
- const tree = sqliteDialect.language.parser.parse(sql);
- const ptr = tree.cursor();
-
- ptr.firstChild();
- ptr.firstChild();
-
- const cursor = new Cursor(ptr, sql);
- cursor.expectKeyword("CREATE");
- cursor.expectKeywordOptional("TEMP");
- cursor.expectKeywordOptional("TEMPORARY");
- cursor.expectKeywordOptional("VIRTUAL");
- cursor.expectKeyword("TABLE");
- cursor.expectKeywordsOptional(["IF", "NOT", "EXIST"]);
+ const cursor = new CursorV2(tokenizeSql(sql, "sqlite"));
+
+ cursor.expectToken("CREATE");
+ cursor.expectTokenOptional("TEMP");
+ cursor.expectTokenOptional("TEMPORARY");
+ cursor.expectTokenOptional("VIRTUAL");
+ cursor.expectToken("TABLE");
+ cursor.expectTokensOptional(["IF", "NOT", "EXIST"]);
+
const tableName = cursor.consumeIdentifier();
// Check for FTS5
@@ -561,19 +574,15 @@ export function parseCreateTableScript(
cursor.next();
if (cursor.match("FTS5")) {
cursor.next();
- fts5 = parseFTS5(cursor.enterParens());
- cursor.next();
+ fts5 = parseFTS5(cursor.consumeParen());
}
}
- const defCursor = cursor.enterParens();
- const defs = defCursor
- ? parseTableDefinition(schemaName, defCursor)
+ const defs = cursor.match("(")
+ ? parseTableDefinition(schemaName, cursor.consumeParen())
: { columns: [], constraints: [] };
- cursor.next();
// Parsing table options
-
const pk = defs.columns.filter((col) => col.pk).map((col) => col.name);
const autoIncrement = defs.columns.some(
diff --git a/src/drivers/sqlite/sql-parse-trigger.test.ts b/src/drivers/sqlite/sql-parse-trigger.test.ts
index 9f171e3c..7345742c 100644
--- a/src/drivers/sqlite/sql-parse-trigger.test.ts
+++ b/src/drivers/sqlite/sql-parse-trigger.test.ts
@@ -20,7 +20,7 @@ function generateSql({
CREATE TRIGGER ${name}
${whenString}${operation}${columnNameString} ON ${tableName}
BEGIN
- ${statement};
+ ${statement}
END;
`;
}
@@ -44,14 +44,19 @@ describe("parse trigger", () => {
const insert = parseCreateTriggerScript(
"main",
- generateSql({ name, operation: "INSERT", tableName, statement })
+ generateSql({
+ name,
+ operation: "INSERT",
+ tableName,
+ statement: statement + statement,
+ })
);
expect(insert).toMatchObject({
name: name,
when: "BEFORE",
operation: "INSERT",
tableName: tableName,
- statement: statement,
+ statement: statement + statement,
});
const updateOf = parseCreateTriggerScript(
diff --git a/src/drivers/sqlite/sql-parse-trigger.ts b/src/drivers/sqlite/sql-parse-trigger.ts
index 8041c193..07feb064 100644
--- a/src/drivers/sqlite/sql-parse-trigger.ts
+++ b/src/drivers/sqlite/sql-parse-trigger.ts
@@ -1,94 +1,95 @@
-import { sqliteDialect } from "@/drivers/sqlite/sqlite-dialect";
-import { Cursor, parseColumnList } from "./sql-parse-table";
import {
DatabaseTriggerSchema,
- TriggerWhen,
TriggerOperation,
+ TriggerWhen,
} from "@/drivers/base-driver";
+import { tokenizeSql } from "@outerbase/sdk-transform";
+import { CursorV2, parseColumnList } from "./sql-parse-table";
-export function parseCreateTriggerScript(schemaName: string, sql: string): DatabaseTriggerSchema {
- const tree = sqliteDialect.language.parser.parse(sql);
- const ptr = tree.cursor();
- ptr.firstChild();
- ptr.firstChild();
- const cursor = new Cursor(ptr, sql);
- cursor.expectKeyword("CREATE");
- cursor.expectKeywordOptional("TEMP");
- cursor.expectKeywordOptional("TEMPORARY");
- cursor.expectKeyword("TRIGGER");
- cursor.expectKeywordsOptional(["IF", "NOT", "EXIST"]);
+export function parseCreateTriggerScript(
+ schemaName: string,
+ sql: string
+): DatabaseTriggerSchema {
+ const cursor = new CursorV2(tokenizeSql(sql, "sqlite"));
+
+ cursor.expectToken("CREATE");
+ cursor.expectTokenOptional("TEMP");
+ cursor.expectTokenOptional("TEMPORARY");
+ cursor.expectToken("TRIGGER");
+ cursor.expectTokensOptional(["IF", "NOT", "EXIST"]);
const name = cursor.consumeIdentifier();
let when: TriggerWhen = "BEFORE";
- if (cursor.matchKeyword("BEFORE")) {
+ if (cursor.match("BEFORE")) {
cursor.next();
- } else if (cursor.matchKeyword("AFTER")) {
+ } else if (cursor.match("AFTER")) {
when = "AFTER";
cursor.next();
- } else if (cursor.matchKeywords(["INSTEAD", "OF"])) {
+ } else if (cursor.match("INSTEAD")) {
+ cursor.expectTokens(["INSTEAD", "OF"]);
when = "INSTEAD_OF";
- cursor.next();
- cursor.next();
}
let operation: TriggerOperation = "INSERT";
let columnNames;
- if (cursor.matchKeyword("DELETE")) {
+ if (cursor.match("DELETE")) {
operation = "DELETE";
cursor.next();
- } else if (cursor.matchKeyword("INSERT")) {
+ } else if (cursor.match("INSERT")) {
operation = "INSERT";
cursor.next();
- } else if (cursor.matchKeyword("UPDATE")) {
+ } else if (cursor.match("UPDATE")) {
operation = "UPDATE";
cursor.next();
- if (cursor.matchKeyword("OF")) {
+ if (cursor.match("OF")) {
cursor.next();
columnNames = parseColumnList(cursor);
}
}
- cursor.expectKeyword("ON");
+ cursor.expectToken("ON");
const tableName = cursor.consumeIdentifier();
- cursor.expectKeywordsOptional(["FOR", "EACH", "ROW"]);
+ cursor.expectTokensOptional(["FOR", "EACH", "ROW"]);
let whenExpression = "";
- const fromExpression = cursor.node()?.from;
+ const fromExpression = cursor.getPointer();
let toExpression;
- if (cursor.matchKeyword("WHEN")) {
+ if (cursor.match("WHEN")) {
// Loop till the end or meet the BEGIN
cursor.next();
while (!cursor.end()) {
- toExpression = cursor.node()?.to;
- if (cursor.matchKeyword("BEGIN")) break;
+ toExpression = cursor.getPointer();
+ if (cursor.match("BEGIN")) break;
cursor.next();
}
}
- if (fromExpression) {
- whenExpression = sql.substring(fromExpression, toExpression);
+ if (fromExpression && toExpression) {
+ whenExpression = cursor.toStringRange(fromExpression, toExpression);
}
- cursor.expectKeyword("BEGIN");
+ cursor.expectToken("BEGIN");
let statement = "";
- const fromStatement = cursor.node()?.from;
+ const fromStatement = cursor.getPointer();
let toStatement;
while (!cursor.end()) {
- toStatement = cursor.node()?.to;
- if (cursor.matchKeyword(";")) {
- break;
+ toStatement = cursor.getPointer();
+ if (cursor.match(";")) {
+ cursor.next();
+ if (cursor.match("END")) break;
+ } else {
+ cursor.next();
}
- cursor.next();
}
- if (fromStatement) {
- statement = sql.substring(fromStatement, toStatement);
+ if (fromStatement && toStatement) {
+ statement = cursor.toStringRange(fromStatement, toStatement + 1);
}
return {
diff --git a/src/drivers/sqlite/sql-parse-view.test.ts b/src/drivers/sqlite/sql-parse-view.test.ts
new file mode 100644
index 00000000..5ffd8ab4
--- /dev/null
+++ b/src/drivers/sqlite/sql-parse-view.test.ts
@@ -0,0 +1,89 @@
+import { parseCreateViewScript } from "./sql-parse-view";
+
+describe("parse", () => {
+ test("parsing simple view", () => {
+ const view = parseCreateViewScript(
+ "main",
+ `CREATE VIEW COMPANY_VIEW AS SELECT ID, NAME, AGE FROM COMPANY;`
+ );
+ expect(view).toMatchObject({
+ schemaName: "main",
+ name: "COMPANY_VIEW",
+ statement: "SELECT ID, NAME, AGE FROM COMPANY",
+ });
+ });
+
+ test("parsing view with temporary keyword", () => {
+ const view = parseCreateViewScript(
+ "main",
+ `CREATE TEMPORARY VIEW TEMP_VIEW AS SELECT * FROM USERS;`
+ );
+ expect(view).toMatchObject({
+ schemaName: "main",
+ name: "TEMP_VIEW",
+ statement: "SELECT * FROM USERS",
+ });
+ });
+
+ test("parsing view with temp keyword", () => {
+ const view = parseCreateViewScript(
+ "main",
+ `CREATE TEMP VIEW TEMP_VIEW AS SELECT * FROM USERS;`
+ );
+ expect(view).toMatchObject({
+ schemaName: "main",
+ name: "TEMP_VIEW",
+ statement: "SELECT * FROM USERS",
+ });
+ });
+
+ test("parsing view with IF NOT EXISTS", () => {
+ const view = parseCreateViewScript(
+ "custom",
+ `CREATE VIEW IF NOT EXIST USER_STATS AS SELECT COUNT(*) AS user_count FROM USERS;`
+ );
+ expect(view).toMatchObject({
+ schemaName: "custom",
+ name: "USER_STATS",
+ statement: "SELECT COUNT(*) AS user_count FROM USERS",
+ });
+ });
+
+ test("parsing complex view with joins", () => {
+ const view = parseCreateViewScript(
+ "main",
+ `CREATE VIEW ORDER_DETAILS AS
+ SELECT o.id, o.date, c.name, p.title
+ FROM orders o
+ JOIN customers c ON o.customer_id = c.id
+ JOIN products p ON o.product_id = p.id;`
+ );
+ expect(view).toMatchObject({
+ schemaName: "main",
+ name: "ORDER_DETAILS",
+ statement: `SELECT o.id, o.date, c.name, p.title
+ FROM orders o
+ JOIN customers c ON o.customer_id = c.id
+ JOIN products p ON o.product_id = p.id`,
+ });
+ });
+
+ test("parsing view with subquery", () => {
+ const view = parseCreateViewScript(
+ "analytics",
+ `CREATE VIEW TOP_CUSTOMERS AS
+ SELECT customer_id, SUM(amount) as total
+ FROM (SELECT * FROM transactions WHERE status = 'completed')
+ GROUP BY customer_id
+ ORDER BY total DESC;`
+ );
+ expect(view).toMatchObject({
+ schemaName: "analytics",
+ name: "TOP_CUSTOMERS",
+ statement: `SELECT customer_id, SUM(amount) as total
+ FROM (SELECT * FROM transactions WHERE status = 'completed')
+ GROUP BY customer_id
+ ORDER BY total DESC`,
+ });
+ });
+});
diff --git a/src/drivers/sqlite/sql-parse-view.ts b/src/drivers/sqlite/sql-parse-view.ts
index 812c3f0d..d9081c0b 100644
--- a/src/drivers/sqlite/sql-parse-view.ts
+++ b/src/drivers/sqlite/sql-parse-view.ts
@@ -1,39 +1,39 @@
-import { sqliteDialect } from "@/drivers/sqlite/sqlite-dialect";
+import { tokenizeSql } from "@outerbase/sdk-transform";
import { DatabaseViewSchema } from "../base-driver";
-import { Cursor } from "./sql-parse-table";
+import { CursorV2 } from "./sql-parse-table";
export function parseCreateViewScript(
schemaName: string,
sql: string
): DatabaseViewSchema {
- const tree = sqliteDialect.language.parser.parse(sql);
- const ptr = tree.cursor();
- ptr.firstChild();
- ptr.firstChild();
- const cursor = new Cursor(ptr, sql);
- cursor.expectKeyword("CREATE");
- cursor.expectKeywordOptional("TEMP");
- cursor.expectKeywordOptional("TEMPORARY");
- cursor.expectKeyword("VIEW");
- cursor.expectKeywordsOptional(["IF", "NOT", "EXIST"]);
+ const cursor = new CursorV2(tokenizeSql(sql, "sqlite"));
+
+ cursor.expectToken("CREATE");
+ cursor.expectTokenOptional("TEMP");
+ cursor.expectTokenOptional("TEMPORARY");
+ cursor.expectToken("VIEW");
+ cursor.expectTokensOptional(["IF", "NOT", "EXIST"]);
+
const name = cursor.consumeIdentifier();
- cursor.expectKeyword("AS");
+ cursor.expectToken("AS");
let statement = "";
- const fromStatement = cursor.node()?.from;
+ const fromStatement = cursor.getPointer();
let toStatement;
while (!cursor.end()) {
- toStatement = cursor.node()?.to;
- if (cursor.matchKeyword(";")) {
+ toStatement = cursor.getPointer();
+
+ if (cursor.match(";")) {
break;
}
+
cursor.next();
}
- if (fromStatement) {
- statement = sql.substring(fromStatement, toStatement);
+ if (fromStatement && toStatement) {
+ statement = cursor.toStringRange(fromStatement, toStatement);
}
return {
diff --git a/src/lib/api-error.ts b/src/lib/api-error.ts
deleted file mode 100644
index cb38aa3b..00000000
--- a/src/lib/api-error.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-interface ApiErrorConstructor {
- message: string;
- status: number;
- detailedMessage?: string;
-}
-
-export class ApiError extends Error {
- detailedMessage?: string;
- status: number;
-
- constructor({ message, status, detailedMessage }: ApiErrorConstructor) {
- super(message);
- this.name = "ApiError";
- this.status = status;
- this.detailedMessage = detailedMessage;
- }
-}
diff --git a/src/lib/api-response-types.ts b/src/lib/api-response-types.ts
deleted file mode 100644
index 26083628..00000000
--- a/src/lib/api-response-types.ts
+++ /dev/null
@@ -1,40 +0,0 @@
-import { SavedConnectionItem } from "@/app/(theme)/connect/saved-connection-storage";
-import {
- DatabaseResultSet,
- DatabaseSchemaItem,
- DatabaseTableSchema,
- DatabaseTriggerSchema,
-} from "@/drivers/base-driver";
-
-export interface ApiOpsBatchResponse {
- error?: string;
- data: DatabaseResultSet[];
-}
-
-export interface ApiOpsQueryResponse {
- error?: string;
- data: DatabaseResultSet;
-}
-
-export interface ApiDatabasesResponse {
- databases: SavedConnectionItem[];
-}
-
-export interface ApiDatabasesResponse {
- databases: SavedConnectionItem[];
-}
-
-export interface ApiSchemaListResponse {
- data: DatabaseSchemaItem[];
- error?: string;
-}
-
-export interface ApiSchemaResponse {
- data: DatabaseTableSchema;
- error?: string;
-}
-
-export interface ApiTriggerResponse {
- data: DatabaseTriggerSchema;
- error?: string;
-}
diff --git a/src/lib/build-table-result.ts b/src/lib/build-table-result.ts
index 3013be75..9bfdf1ba 100644
--- a/src/lib/build-table-result.ts
+++ b/src/lib/build-table-result.ts
@@ -1,4 +1,5 @@
import { OptimizeTableHeaderProps } from "@/components/gui/table-optimized";
+import { TableHeaderMetadata } from "@/components/gui/table-result/type";
import {
BaseDriver,
DatabaseResultSet,
@@ -16,7 +17,7 @@ export interface BuildTableResultProps {
}
function pipeAttachColumnViaSchemas(
- headers: OptimizeTableHeaderProps[],
+ headers: OptimizeTableHeaderProps[],
{ tableSchema, schemas, driver }: BuildTableResultProps
) {
// If there is already table schema, we use it instead because it is more accurate.
@@ -54,7 +55,7 @@ function pipeAttachColumnViaSchemas(
}
function pipeWithTableSchema(
- headers: OptimizeTableHeaderProps[],
+ headers: OptimizeTableHeaderProps[],
{ tableSchema, driver }: BuildTableResultProps
) {
if (!tableSchema) return;
@@ -122,7 +123,7 @@ function pipeWithTableSchema(
* the readonly status of each column according to the table schema.
*/
function pipeEditableTable(
- headers: OptimizeTableHeaderProps[],
+ headers: OptimizeTableHeaderProps[],
{ schemas }: BuildTableResultProps
) {
const tables: {
@@ -197,7 +198,7 @@ function pipeEditableTable(
}
export function pipeVirtualColumnAsReadOnly(
- headers: OptimizeTableHeaderProps[]
+ headers: OptimizeTableHeaderProps[]
) {
for (const header of headers) {
if (header.metadata.columnSchema?.constraint?.generatedExpression) {
@@ -207,7 +208,7 @@ export function pipeVirtualColumnAsReadOnly(
}
export function pipeCalculateInitialSize(
- headers: OptimizeTableHeaderProps[],
+ headers: OptimizeTableHeaderProps[],
{ result }: BuildTableResultProps
) {
for (const header of headers) {
@@ -237,7 +238,9 @@ export function pipeCalculateInitialSize(
}
}
-export function pipeColumnIcon(headers: OptimizeTableHeaderProps[]) {
+export function pipeColumnIcon(
+ headers: OptimizeTableHeaderProps[]
+) {
for (const header of headers) {
if (header.metadata.isPrimaryKey) {
header.display.icon = LucideKey;
@@ -254,7 +257,7 @@ export function pipeColumnIcon(headers: OptimizeTableHeaderProps[]) {
export function buildTableResultHeader(
props: BuildTableResultProps
-): OptimizeTableHeaderProps[] {
+): OptimizeTableHeaderProps[] {
const { result } = props;
const headers = result.headers.map((column) => {
@@ -283,7 +286,7 @@ export function buildTableResultHeader(
originalType: column.originalType,
...(from ? { from } : {}),
},
- } as OptimizeTableHeaderProps;
+ } as OptimizeTableHeaderProps;
});
pipeWithTableSchema(headers, props);
diff --git a/src/lib/encryption-edge.ts b/src/lib/encryption-edge.ts
deleted file mode 100644
index b3147134..00000000
--- a/src/lib/encryption-edge.ts
+++ /dev/null
@@ -1,69 +0,0 @@
-const RANDOM_IV_LENGTH = 12;
-const AUTH_TAG_SIZE = 16;
-
-function base64ToArrayBuffer(base64: string) {
- const binaryString = atob(base64);
- const bytes = new Uint8Array(binaryString.length);
- for (let i = 0; i < binaryString.length; i++) {
- bytes[i] = binaryString.charCodeAt(i);
- }
- return bytes;
-}
-
-function arrayBufferToBase64(buffer: Uint8Array) {
- let binary = "";
- const bytes = new Uint8Array(buffer);
- const len = bytes.byteLength;
- for (let i = 0; i < len; i++) {
- binary += String.fromCharCode(bytes[i]);
- }
- return btoa(binary);
-}
-
-export async function encrypt(keyInBase64: string | undefined, text: string) {
- if (!keyInBase64) throw new Error("Encryption key is not provided");
-
- const iv = crypto.getRandomValues(new Uint8Array(RANDOM_IV_LENGTH));
- const encoded = new TextEncoder().encode(text);
- const keyBuffer = base64ToArrayBuffer(keyInBase64);
-
- const key = await crypto.subtle.importKey(
- "raw",
- keyBuffer,
- { name: "AES-GCM" },
- false,
- ["encrypt"]
- );
-
- const c = await crypto.subtle.encrypt(
- { name: "AES-GCM", iv, tagLength: AUTH_TAG_SIZE * 8 },
- key,
- encoded
- );
-
- return arrayBufferToBase64(new Uint8Array([...iv, ...new Uint8Array(c)]));
-}
-
-export async function decrypt(keyInBase64: string | undefined, base64: string) {
- if (!keyInBase64) throw new Error("Encryption key is not provided");
-
- const key = await crypto.subtle.importKey(
- "raw",
- base64ToArrayBuffer(keyInBase64),
- { name: "AES-GCM" },
- false,
- ["decrypt"]
- );
-
- const e = base64ToArrayBuffer(base64);
- const iv = e.slice(0, RANDOM_IV_LENGTH);
- const content = e.slice(RANDOM_IV_LENGTH);
-
- const c = await crypto.subtle.decrypt(
- { name: "AES-GCM", iv, tagLength: AUTH_TAG_SIZE * 8 },
- key,
- content
- );
-
- return new TextDecoder().decode(c);
-}
diff --git a/src/lib/encryption.test.ts b/src/lib/encryption.test.ts
deleted file mode 100644
index ef4eec88..00000000
--- a/src/lib/encryption.test.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-import crypto from "crypto";
-import { decrypt, encrypt } from "./encryption";
-
-test("Encrypt and decrypt should reverse each other", () => {
- const key = crypto.randomBytes(32);
- const text = "Hello World";
- expect(decrypt(key, encrypt(key, text))).toBe(text);
-});
diff --git a/src/lib/export-helper.ts b/src/lib/export-helper.ts
index a25fd5c4..c20246a7 100644
--- a/src/lib/export-helper.ts
+++ b/src/lib/export-helper.ts
@@ -1,4 +1,5 @@
import {
+ ExportFormat,
ExportOptions,
ExportSelection,
ExportTarget,
@@ -245,3 +246,49 @@ export function convertExcelStringToArray(data: string): string[][] {
const lines = data.split("\r\n");
return lines.map((line) => line.split("\t"));
}
+
+export async function exportTableData(
+ databaseDriver: any,
+ schemaName: string,
+ tableName: string,
+ format: ExportFormat,
+ exportTarget: ExportTarget,
+ options?: ExportOptions
+): Promise {
+ console.log("Exporting", schemaName, tableName, format, exportTarget, options);
+ const result = await databaseDriver.query(
+ `SELECT * FROM ${databaseDriver.escapeId(schemaName)}.${databaseDriver.escapeId(tableName)}`
+ );
+ console.log("QueryResults", result);
+ if (!result.rows || result.rows.length === 0) {
+ return "";
+ }
+
+ const headers = Object.keys(result.rows[0]);
+ const records = result.rows.map((row: { [x: string]: string; }) => headers.map(header => row[header]));
+
+ const formatHandlers = {
+ csv: () => exportDataAsDelimitedText(headers, records, ",", "\n", '"', exportTarget),
+ json: () => exportRowsToJson(headers, records, exportTarget),
+ sql: () => exportRowsToSqlInsert(tableName, headers, records, exportTarget),
+ xlsx: () => exportToExcel(records, headers, tableName, exportTarget),
+ delimited: () =>
+ exportDataAsDelimitedText(
+ headers,
+ records,
+ options?.fieldSeparator || ",",
+ options?.lineTerminator || "\n",
+ options?.encloser || '"',
+ exportTarget
+ ),
+ };
+
+ const handler = formatHandlers[format];
+ if (handler) {
+ return handler();
+ } else {
+ throw new Error(`Unsupported export format: ${format}`);
+ }
+}
+// TODO: maybe we should move export related types here
+export type { ExportFormat };
diff --git a/src/lib/hash-edge.ts b/src/lib/hash-edge.ts
deleted file mode 100644
index 1960f398..00000000
--- a/src/lib/hash-edge.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-import { scoped } from "./utils";
-
-/**
- * Generate a SHA-1 hash of a string or BufferSource using the Web Crypto API
- * @param input - string or BufferSource to hash
- * @returns Promise that resolves to the hashed string
- */
-export const hash = async (input: string | BufferSource) => {
- // Convert the input string to a Uint8Array
-
- const data = scoped(() => {
- if (typeof input === "string") {
- return new TextEncoder().encode(input);
- }
- return input;
- });
-
- const subtle = crypto.subtle;
-
- const hashBuffer = await subtle.digest("SHA-1", data);
-
- // Convert the hashBuffer to a hexadecimal string
- const hashArray = Array.from(new Uint8Array(hashBuffer));
- const hashHex = hashArray
- .map((b) => b.toString(16).padStart(2, "0"))
- .join("");
-
- return hashHex;
-};
diff --git a/src/lib/internal-pubsub.ts b/src/lib/internal-pubsub.ts
deleted file mode 100644
index ec50eb65..00000000
--- a/src/lib/internal-pubsub.ts
+++ /dev/null
@@ -1,30 +0,0 @@
-export default class InternalPubSub {
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
- protected listeners: Record void>> = {};
-
- addListener(channel: string, callback: (obj: T) => void) {
- const c = this.listeners[channel];
- if (c) {
- c.push(callback);
- } else {
- this.listeners[channel] = [callback];
- }
- }
-
- removeListener(channel: string, callback: (obj: T) => void) {
- const c = this.listeners[channel];
- if (c) {
- c.filter((c) => c !== callback);
- if (c.length) {
- delete this.listeners[channel];
- }
- }
- }
-
- send(channel: string, obj: T) {
- const listeners = this.listeners[channel];
- if (listeners) {
- listeners.forEach((callback) => callback(obj));
- }
- }
-}
diff --git a/src/lib/utils.ts b/src/lib/utils.ts
index e66db744..b151139b 100644
--- a/src/lib/utils.ts
+++ b/src/lib/utils.ts
@@ -4,84 +4,11 @@ import { twMerge } from "tailwind-merge";
export function cn(...inputs: ClassValue[]) {
return twMerge(clsx(inputs));
}
-
-/**
- * Funny workaround to make a scoped feature
- */
-export function scoped(fn: () => T): T {
- return fn();
-}
-
-/**
- * Join everything together into a string
- *
- * @example
- * const result = concat("henlo", "-", "world")
- * // "henlo-world"
- */
-export function concat(...inputs: string[]) {
- return inputs.join("");
-}
-
export interface ApiErrorResponse {
message: string;
detailedMessage?: string;
}
-/**
- * Safely fetch data with a slightly typed response
- *
- * @example
- *
- * const { data, error } = await safeFetch(url)
- * if (error) {
- * console.log(error.message, error.detailedMessage)
- * } else {
- * console.log(data) // type User
- * }
- */
-export async function safeFetch(
- url: string | URL,
- init?: RequestInit
-): Promise<
- | {
- data: Success;
- error: null;
- response: Response;
- }
- | {
- data: null;
- error: ApiErrorResponse;
- response: Response;
- }
-> {
- let response: Response = new Response();
- try {
- response = await fetch(url, init);
- if (!response.ok) {
- const json = await response.json();
- return { data: null, error: json?.error || json, response };
- } else {
- const data = await response.json();
- return { data, error: null, response };
- }
- } catch (e) {
- if (e instanceof Error) {
- return {
- response,
- data: null,
- error: { message: "Something went wrong", detailedMessage: e.message },
- };
- }
-
- return {
- response,
- data: null,
- error: { message: "Unknown Error", detailedMessage: JSON.stringify(e) },
- };
- }
-}
-
export function strippedWorkspaceName(value: string) {
return value
.replace(
diff --git a/src/lib/with-error-handler.ts b/src/lib/with-error-handler.ts
deleted file mode 100644
index b4eed82e..00000000
--- a/src/lib/with-error-handler.ts
+++ /dev/null
@@ -1,42 +0,0 @@
-import { NextRequest, NextResponse } from "next/server";
-import { ApiError } from "./api-error";
-import { HttpStatus } from "@/constants/http-status";
-
-type WithErrorHandler = (props: {
- req: NextRequest;
- params: T;
-}) => Promise;
-
-export default function withErrorHandler(
- handler: WithErrorHandler
-) {
- return async function (req: NextRequest, params: ParamsType) {
- try {
- return await handler({ req, params });
- } catch (e) {
- // TODO: can extract this to a separate function
- if (e instanceof ApiError) {
- return new Response(
- JSON.stringify({
- message: e.message,
- detailedMessage: e.detailedMessage,
- }),
- { status: e.status }
- );
- }
-
- return new Response(
- JSON.stringify({
- message: "Something went wrong",
- detailedMessage: e instanceof Error ? e.message : "Unknown Error",
- }),
- {
- status: HttpStatus.INTERNAL_SERVER_ERROR,
- headers: {
- "Content-Type": "application/json",
- },
- }
- );
- }
- };
-}
| | |