@boltapp/bolt-app-db 0.0.1

package/dist/client/schema/table-schema.js

@@ -0,0 +1,99 @@
+import { TABLE_VIEW_DISPLAY_TYPES } from "@boltapp/bolt-core/data-table/schemas/views/display";
+import { ACTION_TYPES } from "@boltapp/bolt-core/data-table/table-action-schemas";
+import { relations } from "drizzle-orm";
+import { index, integer, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
+import { nanoid } from "nanoid";
+import { boltProjects } from "./project-schema";
+export const boltTables = sqliteTable("bolt_tables", {
+    id: text()
+        .primaryKey()
+        .$defaultFn(() => nanoid()),
+    name: text().notNull(),
+    label: text().default("Untitled Table").notNull(),
+    description: text(),
+    idField: text().default("id").notNull(),
+    displayColumn: text().notNull(),
+    columns: text({ mode: "json" }).$type(),
+    rows: text({ mode: "json" }).$type(),
+    projectId: text()
+        .notNull()
+        .references(() => boltProjects.id, { onDelete: "cascade" }),
+    organizationId: text(),
+    createdBy: text().default("system").notNull(),
+    updatedBy: text().default("system").notNull(),
+    createdAt: integer({ mode: "timestamp" }),
+    updatedAt: integer({ mode: "timestamp" }),
+}, (table) => [
+    uniqueIndex("bolt_tables_project_name_unique_idx").on(table.projectId, table.name),
+    index("bolt_tables_project_idx").on(table.projectId),
+]);
+export const boltTableViews = sqliteTable("bolt_table_views", {
+    id: text()
+        .primaryKey()
+        .$defaultFn(() => nanoid()),
+    name: text().notNull(),
+    label: text().default("Untitled View").notNull(),
+    tableId: text()
+        .notNull()
+        .references(() => boltTables.id, { onDelete: "cascade" }),
+    description: text(),
+    display: text({ enum: TABLE_VIEW_DISPLAY_TYPES }).default("table").notNull(),
+    visibleColumnIds: text({ mode: "json" }).$type().notNull(),
+    sorting: text({ mode: "json" }).$type(),
+    showRowNumbers: integer({ mode: "boolean" }),
+    rowHeight: integer({ mode: "number" }),
+    displayConfig: text({ mode: "json" }).$type().notNull(),
+    projectId: text().references(() => boltProjects.id, { onDelete: "cascade" }),
+    organizationId: text(),
+    createdBy: text(),
+    createdAt: integer({ mode: "timestamp" }),
+    updatedAt: integer({ mode: "timestamp" }),
+}, (table) => [
+    index("bolt_table_views_table_id_idx").on(table.tableId),
+    index("bolt_table_views_project_idx").on(table.projectId),
+]);
+export const boltTableOps = sqliteTable("bolt_table_ops", {
+    id: text().$defaultFn(() => nanoid()),
+    serverSeq: integer("server_seq").primaryKey({ autoIncrement: true }),
+    clientActionId: text(),
+    type: text({ enum: ACTION_TYPES }).notNull(),
+    rowId: text(),
+    colId: text(),
+    tableId: text()
+        .notNull()
+        .references(() => boltTables.id, { onDelete: "cascade" }),
+    source: text({ enum: ["client", "api", "server"] })
+        .default("server")
+        .notNull(),
+    payload: text({ mode: "json" }).$type().notNull(),
+    basisRowVersion: integer("basis_row_version", { mode: "number" }),
+    basisTableVersion: integer("basis_table_version", { mode: "number" }),
+    userId: text().notNull(),
+    createdAt: integer({ mode: "timestamp" }),
+}, (table) => [
+    index("bolt_table_ops_table_seq_idx").on(table.tableId, table.serverSeq),
+    index("bolt_table_ops_table_idx").on(table.tableId),
+    index("bolt_table_ops_row_idx").on(table.rowId),
+    index("bolt_table_ops_col_idx").on(table.colId),
+    index("bolt_table_ops_type_idx").on(table.type),
+]);
+export const boltTablesRelations = relations(boltTables, ({ many, one }) => ({
+    views: many(boltTableViews),
+    ops: many(boltTableOps),
+    project: one(boltProjects, {
+        fields: [boltTables.projectId],
+        references: [boltProjects.id],
+    }),
+}));
+export const boltTableViewsRelations = relations(boltTableViews, ({ one }) => ({
+    table: one(boltTables, {
+        fields: [boltTableViews.tableId],
+        references: [boltTables.id],
+    }),
+}));
+export const boltTableOpsRelations = relations(boltTableOps, ({ one }) => ({
+    table: one(boltTables, {
+        fields: [boltTableOps.tableId],
+        references: [boltTables.id],
+    }),
+}));

package/dist/cloud-app/schema/data-store-schemas.d.ts

@@ -0,0 +1,220 @@
+import { DataStoreItem } from "@boltapp/bolt-core/data-stores/types";
+export declare const boltDataStores: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "bolt_data_stores";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "bolt_data_stores";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        name: import("drizzle-orm/pg-core").PgColumn<{
+            name: "name";
+            tableName: "bolt_data_stores";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        label: import("drizzle-orm/pg-core").PgColumn<{
+            name: "label";
+            tableName: "bolt_data_stores";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        description: import("drizzle-orm/pg-core").PgColumn<{
+            name: "description";
+            tableName: "bolt_data_stores";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        items: import("drizzle-orm/pg-core").PgColumn<{
+            name: "schema";
+            tableName: "bolt_data_stores";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: DataStoreItem[];
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: DataStoreItem[];
+        }>;
+        data: import("drizzle-orm/pg-core").PgColumn<{
+            name: "data";
+            tableName: "bolt_data_stores";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+        appId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "app_id";
+            tableName: "bolt_data_stores";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        organizationId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "organization_id";
+            tableName: "bolt_data_stores";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdBy: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_by";
+            tableName: "bolt_data_stores";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedBy: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_by";
+            tableName: "bolt_data_stores";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "bolt_data_stores";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "bolt_data_stores";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const boltDataStoresRelations: import("drizzle-orm").Relations<"bolt_data_stores", {
+    app: import("drizzle-orm").One<"apps", true>;
+}>;
+export type BoltDataStoreCloud = typeof boltDataStores.$inferSelect;

package/dist/cloud-app/schema/data-store-schemas.js

@@ -0,0 +1,32 @@
+import { relations } from "drizzle-orm";
+import { index, jsonb, pgTable, text, timestamp, uniqueIndex } from "drizzle-orm/pg-core";
+import { nanoid } from "nanoid";
+import { apps } from "./schema";
+export const boltDataStores = pgTable("bolt_data_stores", {
+    id: text("id")
+        .primaryKey()
+        .$defaultFn(() => nanoid()),
+    name: text("name").notNull(),
+    label: text("label").default("Untitled Store").notNull(),
+    description: text("description"),
+    items: jsonb("schema").$type(),
+    data: jsonb("data").$type().default({}).notNull(),
+    appId: text("app_id")
+        .notNull()
+        .references(() => apps.id, { onDelete: "cascade" }),
+    organizationId: text("organization_id"),
+    createdBy: text("created_by").default("system").notNull(),
+    updatedBy: text("updated_by").default("system").notNull(),
+    createdAt: timestamp("created_at").defaultNow(),
+    updatedAt: timestamp("updated_at").defaultNow(),
+}, (table) => [
+    uniqueIndex("bolt_data_stores_app_name_unique_idx").on(table.appId, table.name),
+    index("bolt_data_stores_app_idx").on(table.appId),
+    index("bolt_data_stores_organization_idx").on(table.organizationId),
+]);
+export const boltDataStoresRelations = relations(boltDataStores, ({ one }) => ({
+    app: one(apps, {
+        fields: [boltDataStores.appId],
+        references: [apps.id],
+    }),
+}));