ta_data_mas 0.0.2

package/apps/api/src/table-editor/table-editor.controller.ts

@@ -0,0 +1,117 @@
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Param,
+  Patch,
+  Post,
+  Query,
+  UseGuards,
+} from '@nestjs/common';
+import { TableEditorService } from './table-editor.service';
+import { CreateTableDto } from './dto/create-table.dto';
+import { AddColumnDto } from './dto/alter-table.dto';
+import { JwtAuthGuard } from '../auth/guards/jwt-auth-guard';
+import { OrgRoleGuard } from '../auth/guards/org-role.guards';
+
+@Controller('orgs/:slug/projects/:projectSlug/tables')
+@UseGuards(JwtAuthGuard, OrgRoleGuard)
+export class TableEditorController {
+  constructor(private tableEditorService: TableEditorService) {}
+
+  @Get()
+  getTables(
+    @Param('slug') slug: string,
+    @Param('projectSlug') projectSlug: string,
+  ) {
+    return this.tableEditorService.getTables(slug, projectSlug);
+  }
+
+  @Get(':tableName/rows')
+  getTableRows(
+    @Param('slug') slug: string,
+    @Param('projectSlug') projectSlug: string,
+    @Param('tableName') tableName: string,
+    @Query('limit') limit?: string,
+    @Query('offset') offset?: string,
+  ) {
+    return this.tableEditorService.getTableRows(
+      slug,
+      projectSlug,
+      tableName,
+      limit ? parseInt(limit, 10) : 100,
+      offset ? parseInt(offset, 10) : 0,
+    );
+  }
+
+  @Get(':tableName')
+  getTableInfo(
+    @Param('slug') slug: string,
+    @Param('projectSlug') projectSlug: string,
+    @Param('tableName') tableName: string,
+  ) {
+    return this.tableEditorService.getTableInfo(slug, projectSlug, tableName);
+  }
+
+  @Post()
+  createTable(
+    @Param('slug') slug: string,
+    @Param('projectSlug') projectSlug: string,
+    @Body() dto: CreateTableDto,
+  ) {
+    return this.tableEditorService.createTable(slug, projectSlug, dto);
+  }
+
+  @Patch(':tableName/columns')
+  addColumn(
+    @Param('slug') slug: string,
+    @Param('projectSlug') projectSlug: string,
+    @Param('tableName') tableName: string,
+    @Body() dto: AddColumnDto,
+  ) {
+    return this.tableEditorService.addColumn(slug, projectSlug, tableName, dto);
+  }
+
+  @Delete(':tableName/columns/:columnName')
+  dropColumn(
+    @Param('slug') slug: string,
+    @Param('projectSlug') projectSlug: string,
+    @Param('tableName') tableName: string,
+    @Param('columnName') columnName: string,
+  ) {
+    return this.tableEditorService.dropColumn(
+      slug,
+      projectSlug,
+      tableName,
+      columnName,
+    );
+  }
+
+  @Delete(':tableName')
+  deleteTable(
+    @Param('slug') slug: string,
+    @Param('projectSlug') projectSlug: string,
+    @Param('tableName') tableName: string,
+  ) {
+    return this.tableEditorService.deleteTable(slug, projectSlug, tableName);
+  }
+
+  @Patch(':tableName/rows/:pkValue')
+  updateRow(
+    @Param('slug') slug: string,
+    @Param('projectSlug') projectSlug: string,
+    @Param('tableName') tableName: string,
+    @Param('pkValue') pkValue: string,
+    @Body() body: { pkColumn: string; updates: Record<string, unknown> },
+  ) {
+    return this.tableEditorService.updateRow(
+      slug,
+      projectSlug,
+      tableName,
+      body.pkColumn,
+      pkValue,
+      body.updates,
+    );
+  }
+}

package/apps/api/src/table-editor/table-editor.module.ts

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common';
+import { AuthModule } from '../auth/auth.module';
+import { TableEditorService } from './table-editor.service';
+import { TableEditorController } from './table-editor.controller';
+import { OrgRoleGuard } from 'src/auth/guards/org-role.guards';
+
+@Module({
+  imports: [AuthModule],
+  providers: [TableEditorService, OrgRoleGuard],
+  controllers: [TableEditorController],
+})
+export class TableEditorModule {}

package/apps/api/src/table-editor/table-editor.service.ts

@@ -0,0 +1,366 @@
+import {
+  BadRequestException,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { and, eq, sql } from 'drizzle-orm';
+import { DrizzleService } from '../db/drizzle.service';
+import { projects, organizations } from '../db/schema';
+import { CreateTableDto } from './dto/create-table.dto';
+import { AddColumnDto } from './dto/alter-table.dto';
+import type { TableInfo, TableColumn, ColumnType } from '@apiDatabase/types';
+
+@Injectable()
+export class TableEditorService {
+  constructor(private drizzle: DrizzleService) {}
+
+  private assertSafeIdentifier(name: string, label: string): void {
+    if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+      throw new BadRequestException(`Invalid ${label}: ${name}`);
+    }
+  }
+
+  //   Type mapping
+  private mapPgTypeToColumnType(pgType: string): ColumnType {
+    const map: Record<string, ColumnType> = {
+      text: 'text',
+      'character varying': 'text',
+      integer: 'integer',
+      bigint: 'bigint',
+      boolean: 'boolean',
+      'timestamp with time zone': 'timestamp',
+      'timestamp without time zone': 'timestamp',
+      uuid: 'uuid',
+      jsonb: 'jsonb',
+      numeric: 'numeric',
+      array: 'array',
+    };
+    return map[pgType] ?? 'text';
+  }
+
+  private mapType(type: string): string {
+    const map: Record<string, string> = {
+      text: 'TEXT',
+      integer: 'INTEGER',
+      bigint: 'BIGINT',
+      boolean: 'BOOLEAN',
+      timestamp: 'TIMESTAMPTZ',
+      uuid: 'UUID',
+      jsonb: 'JSONB',
+      numeric: 'NUMERIC',
+      array: 'ARRAY',
+    };
+    return map[type] ?? 'TEXT';
+  }
+
+  private formatDefault(value: string, type: ColumnType): string {
+    const trimmed = value.trim();
+    if (!trimmed) return '';
+
+    if (/^(now\(\)|gen_random_uuid\(\)|current_timestamp)$/i.test(trimmed)) {
+      return trimmed;
+    }
+    if (type === 'boolean') return trimmed;
+    if (type === 'integer' || type === 'bigint' || type === 'numeric') {
+      return trimmed;
+    }
+    if (type === 'jsonb') return `'${trimmed.replace(/'/g, "''")}'::jsonb`;
+    return `'${trimmed.replace(/'/g, "''")}'`;
+  }
+
+  private async getProjectSchema(
+    orgSlug: string,
+    projectSlug: string,
+  ): Promise<string> {
+    const [row] = await this.drizzle.db
+      .select({ dbSchema: projects.dbSchema })
+      .from(projects)
+      .innerJoin(organizations, eq(projects.orgId, organizations.id))
+      .where(
+        and(eq(organizations.slug, orgSlug), eq(projects.slug, projectSlug)),
+      )
+      .limit(1);
+
+    if (!row) throw new NotFoundException('Project not found');
+    return row.dbSchema;
+  }
+
+  //   List tables
+  async getTables(orgSlug: string, projectSlug: string): Promise<string[]> {
+    const schema = await this.getProjectSchema(orgSlug, projectSlug);
+
+    const result = await this.drizzle.db.execute<{ table_name: string }>(
+      `SELECT table_name
+       FROM information_schema.tables
+       WHERE table_schema = '${schema}'
+         AND table_type = 'BASE TABLE'
+       ORDER BY table_name ASC`,
+    );
+
+    return result.rows.map((r) => r.table_name);
+  }
+
+  // Get table structure
+  async getTableInfo(
+    orgSlug: string,
+    projectSlug: string,
+    tableName: string,
+  ): Promise<TableInfo> {
+    this.assertSafeIdentifier(tableName, 'table name');
+    const schema = await this.getProjectSchema(orgSlug, projectSlug);
+
+    const columnsResult = await this.drizzle.db.execute<{
+      column_name: string;
+      data_type: string;
+      is_nullable: string;
+      column_default: string | null;
+    }>(
+      `SELECT column_name, data_type, is_nullable, column_default
+       FROM information_schema.columns
+       WHERE table_schema = '${schema}'
+         AND table_name = '${tableName}'
+       ORDER BY ordinal_position ASC`,
+    );
+
+    const pkResult = await this.drizzle.db.execute<{ column_name: string }>(
+      `SELECT kcu.column_name
+       FROM information_schema.table_constraints tc
+       JOIN information_schema.key_column_usage kcu
+         ON tc.constraint_name = kcu.constraint_name
+         AND tc.table_schema = kcu.table_schema
+       WHERE tc.constraint_type = 'PRIMARY KEY'
+         AND tc.table_schema = '${schema}'
+         AND tc.table_name = '${tableName}'`,
+    );
+
+    const pkColumns = new Set(pkResult.rows.map((r) => r.column_name));
+
+    const fkResult = await this.drizzle.db.execute<{
+      column_name: string;
+      foreign_table_name: string;
+      foreign_column_name: string;
+    }>(
+      `SELECT
+         kcu.column_name,
+         ccu.table_name AS foreign_table_name,
+         ccu.column_name AS foreign_column_name
+       FROM information_schema.table_constraints tc
+       JOIN information_schema.key_column_usage kcu
+         ON tc.constraint_name = kcu.constraint_name
+         AND tc.table_schema = kcu.table_schema
+       JOIN information_schema.constraint_column_usage ccu
+         ON ccu.constraint_name = tc.constraint_name
+       WHERE tc.constraint_type = 'FOREIGN KEY'
+         AND tc.table_schema = '${schema}'
+         AND tc.table_name = '${tableName}'`,
+    );
+
+    const fkMap = new Map(
+      fkResult.rows.map((r) => [
+        r.column_name,
+        { table: r.foreign_table_name, column: r.foreign_column_name },
+      ]),
+    );
+
+    const columns: TableColumn[] = columnsResult.rows.map((col) => ({
+      name: col.column_name,
+      type: this.mapPgTypeToColumnType(col.data_type),
+      isNullable: col.is_nullable === 'YES',
+      isPrimaryKey: pkColumns.has(col.column_name),
+      defaultValue: col.column_default,
+      foreignKey: fkMap.get(col.column_name) ?? null,
+    }));
+
+    if (columns.length === 0) {
+      throw new NotFoundException(`Table "${tableName}" not found`);
+    }
+
+    return { name: tableName, columns };
+  }
+
+  private isMissingTableError(err: unknown): boolean {
+    const code =
+      err &&
+      typeof err === 'object' &&
+      'cause' in err &&
+      err.cause &&
+      typeof err.cause === 'object' &&
+      'code' in err.cause
+        ? String(err.cause.code)
+        : null;
+
+    return code === '42P01';
+  }
+
+  // Get table rows
+  async getTableRows(
+    orgSlug: string,
+    projectSlug: string,
+    tableName: string,
+    limit = 100,
+    offset = 0,
+  ): Promise<{ rows: Record<string, unknown>[]; count: number }> {
+    this.assertSafeIdentifier(tableName, 'table name');
+    const schema = await this.getProjectSchema(orgSlug, projectSlug);
+
+    try {
+      const [rowsResult, countResult] = await Promise.all([
+        this.drizzle.db.execute<Record<string, unknown>>(
+          `SELECT * FROM "${schema}"."${tableName}" LIMIT ${limit} OFFSET ${offset}`,
+        ),
+        this.drizzle.db.execute<{ count: string }>(
+          `SELECT COUNT(*) as count FROM "${schema}"."${tableName}"`,
+        ),
+      ]);
+
+      return {
+        rows: rowsResult.rows,
+        count: parseInt(countResult.rows[0]?.count ?? '0', 10),
+      };
+    } catch (err) {
+      if (this.isMissingTableError(err)) {
+        throw new NotFoundException(`Table "${tableName}" not found`);
+      }
+      throw err;
+    }
+  }
+
+  // Create table
+  async createTable(
+    orgSlug: string,
+    projectSlug: string,
+    dto: CreateTableDto,
+  ): Promise<void> {
+    this.assertSafeIdentifier(dto.name, 'table name');
+    const schema = await this.getProjectSchema(orgSlug, projectSlug);
+
+    const pkCols = dto.columns.filter((c) => c.isPrimaryKey);
+
+    const columnDefs = dto.columns.map((col) => {
+      this.assertSafeIdentifier(col.name, 'column name');
+
+      if (col.foreignKeyTable) {
+        this.assertSafeIdentifier(col.foreignKeyTable, 'foreign key table');
+      }
+      if (col.foreignKeyColumn) {
+        this.assertSafeIdentifier(col.foreignKeyColumn, 'foreign key column');
+      }
+
+      const parts: string[] = [];
+      let colDef = `"${col.name}" ${this.mapType(col.type)}`;
+
+      if (col.isPrimaryKey && col.type === 'bigint' && !col.defaultValue) {
+        colDef += ' GENERATED ALWAYS AS IDENTITY';
+      }
+
+      parts.push(colDef);
+
+      if (col.isPrimaryKey && pkCols.length === 1) parts.push('PRIMARY KEY');
+      if (!col.isNullable && !col.isPrimaryKey) parts.push('NOT NULL');
+      if (col.defaultValue) {
+        parts.push(`DEFAULT ${this.formatDefault(col.defaultValue, col.type)}`);
+      }
+
+      return parts.join(' ');
+    });
+
+    const pkConstraint =
+      pkCols.length > 1
+        ? `PRIMARY KEY (${pkCols.map((c) => `"${c.name}"`).join(', ')})`
+        : null;
+
+    const fkConstraints = dto.columns
+      .filter((col) => col.foreignKeyTable && col.foreignKeyColumn)
+      .map(
+        (col) =>
+          `FOREIGN KEY ("${col.name}") REFERENCES "${schema}"."${col.foreignKeyTable!}" ("${col.foreignKeyColumn!}")`,
+      );
+
+    const allDefs = [
+      ...columnDefs,
+      ...(pkConstraint ? [pkConstraint] : []),
+      ...fkConstraints,
+    ].join(', ');
+
+    await this.drizzle.db.execute(
+      `CREATE TABLE "${schema}"."${dto.name}" (${allDefs})`,
+    );
+  }
+
+  // Delete table
+  async deleteTable(
+    orgSlug: string,
+    projectSlug: string,
+    tableName: string,
+  ): Promise<void> {
+    this.assertSafeIdentifier(tableName, 'table name');
+    const schema = await this.getProjectSchema(orgSlug, projectSlug);
+    await this.drizzle.db.execute(
+      `DROP TABLE IF EXISTS "${schema}"."${tableName}"`,
+    );
+  }
+
+  // Add column
+  async addColumn(
+    orgSlug: string,
+    projectSlug: string,
+    tableName: string,
+    dto: AddColumnDto,
+  ): Promise<void> {
+    this.assertSafeIdentifier(tableName, 'table name');
+    this.assertSafeIdentifier(dto.name, 'column name');
+    const schema = await this.getProjectSchema(orgSlug, projectSlug);
+
+    let colDef = `"${dto.name}" ${this.mapType(dto.type)}`;
+    if (dto.defaultValue) {
+      colDef += ` DEFAULT ${this.formatDefault(dto.defaultValue, dto.type)}`;
+    }
+
+    await this.drizzle.db.execute(
+      `ALTER TABLE "${schema}"."${tableName}" ADD COLUMN ${colDef}`,
+    );
+  }
+
+  // Drop column
+  async dropColumn(
+    orgSlug: string,
+    projectSlug: string,
+    tableName: string,
+    columnName: string,
+  ): Promise<void> {
+    this.assertSafeIdentifier(tableName, 'table name');
+    this.assertSafeIdentifier(columnName, 'column name');
+    const schema = await this.getProjectSchema(orgSlug, projectSlug);
+    await this.drizzle.db.execute(
+      `ALTER TABLE "${schema}"."${tableName}" DROP COLUMN "${columnName}"`,
+    );
+  }
+
+  // Update row
+  async updateRow(
+    orgSlug: string,
+    projectSlug: string,
+    tableName: string,
+    pkColumn: string,
+    pkValue: string,
+    updates: Record<string, unknown>,
+  ): Promise<void> {
+    this.assertSafeIdentifier(tableName, 'table name');
+    this.assertSafeIdentifier(pkColumn, 'primary key column');
+    Object.keys(updates).forEach((col) =>
+      this.assertSafeIdentifier(col, 'column name'),
+    );
+
+    const schema = await this.getProjectSchema(orgSlug, projectSlug);
+
+    const setFragments = Object.entries(updates).map(
+      ([col, val]) => sql`${sql.identifier(col)} = ${val}`,
+    );
+
+    await this.drizzle.db.execute(
+      sql`UPDATE ${sql.identifier(schema)}.${sql.identifier(tableName)}
+          SET ${sql.join(setFragments, sql`, `)}
+          WHERE ${sql.identifier(pkColumn)} = ${pkValue}`,
+    );
+  }
+}

package/apps/api/test/app.e2e-spec.ts

@@ -0,0 +1,29 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { INestApplication } from '@nestjs/common';
+import request from 'supertest';
+import { App } from 'supertest/types';
+import { AppModule } from './../src/app.module';
+
+describe('AppController (e2e)', () => {
+  let app: INestApplication<App>;
+
+  beforeEach(async () => {
+    const moduleFixture: TestingModule = await Test.createTestingModule({
+      imports: [AppModule],
+    }).compile();
+
+    app = moduleFixture.createNestApplication();
+    await app.init();
+  });
+
+  it('/ (GET)', () => {
+    return request(app.getHttpServer())
+      .get('/')
+      .expect(200)
+      .expect('Hello World!');
+  });
+
+  afterEach(async () => {
+    await app.close();
+  });
+});

package/apps/api/test/jest-e2e.json

@@ -0,0 +1,9 @@
+{
+  "moduleFileExtensions": ["js", "json", "ts"],
+  "rootDir": ".",
+  "testEnvironment": "node",
+  "testRegex": ".e2e-spec.ts$",
+  "transform": {
+    "^.+\\.(t|j)s$": "ts-jest"
+  }
+}

package/apps/api/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["node_modules", "test", "dist", "**/*spec.ts"]
+}

package/apps/api/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "resolvePackageJsonExports": true,
+    "esModuleInterop": true,
+    "isolatedModules": true,
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "target": "ES2023",
+    "sourceMap": true,
+    "outDir": "./dist",
+    "baseUrl": "./",
+    "incremental": true,
+    "skipLibCheck": true,
+    "strictNullChecks": true,
+    "forceConsistentCasingInFileNames": true,
+    "noImplicitAny": false,
+    "strictBindCallApply": false,
+    "noFallthroughCasesInSwitch": false
+  }
+}

package/apps/web/.env.example

@@ -0,0 +1,12 @@
+# NestJS API (include /api prefix)
+# Used by Server Components, Server Actions, and the /api/proxy route
+API_URL=http://localhost:3000/api
+
+# Browser-facing API base (local = full URL; production can be /api/proxy)
+NEXT_PUBLIC_API_URL=http://localhost:3000/api
+
+# Optional — where users land after OAuth (defaults to http://localhost:3001)
+NEXT_PUBLIC_WEB_URL=http://localhost:3001
+
+# Optional — WebSocket origin for realtime (defaults to API host without /api)
+# NEXT_PUBLIC_REALTIME_URL=http://localhost:3000

package/apps/web/AGENTS.md

@@ -0,0 +1,9 @@
+<!-- BEGIN:nextjs-agent-rules -->
+
+# This is NOT the Next.js you know
+
+This version has breaking changes — APIs, conventions, and file structure may all differ from your training data. Read the relevant guide in `node_modules/next/dist/docs/` (resolved from this file's directory; in monorepos the `next` package may not be visible from the repo root) before writing any code. Heed deprecation notices.
+
+This block is written and re-added by `next dev` — verify at `node_modules/next/dist/server/lib/generate-agent-files.js`. Removing it from a diff only re-creates the uncommitted change; committing it with your work keeps the tree clean.
+
+<!-- END:nextjs-agent-rules -->

package/apps/web/CLAUDE.md

@@ -0,0 +1 @@
+@AGENTS.md

package/apps/web/README.md

@@ -0,0 +1,36 @@
+This is a [Next.js](https://nextjs.org) project bootstrapped with [`create-next-app`](https://nextjs.org/docs/app/api-reference/cli/create-next-app).
+
+## Getting Started
+
+First, run the development server:
+
+```bash
+npm run dev
+# or
+yarn dev
+# or
+pnpm dev
+# or
+bun dev
+```
+
+Open [http://localhost:3000](http://localhost:3000) with your browser to see the result.
+
+You can start editing the page by modifying `app/page.tsx`. The page auto-updates as you edit the file.
+
+This project uses [`next/font`](https://nextjs.org/docs/app/building-your-application/optimizing/fonts) to automatically optimize and load [Geist](https://vercel.com/font), a new font family for Vercel.
+
+## Learn More
+
+To learn more about Next.js, take a look at the following resources:
+
+- [Next.js Documentation](https://nextjs.org/docs) - learn about Next.js features and API.
+- [Learn Next.js](https://nextjs.org/learn) - an interactive Next.js tutorial.
+
+You can check out [the Next.js GitHub repository](https://github.com/vercel/next.js) - your feedback and contributions are welcome!
+
+## Deploy on Vercel
+
+The easiest way to deploy your Next.js app is to use the [Vercel Platform](https://vercel.com/new?utm_medium=default-template&filter=next.js&utm_source=create-next-app&utm_campaign=create-next-app-readme) from the creators of Next.js.
+
+Check out our [Next.js deployment documentation](https://nextjs.org/docs/app/building-your-application/deploying) for more details.

package/apps/web/components.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://ui.shadcn.com/schema.json",
+  "style": "radix-nova",
+  "rsc": true,
+  "tsx": true,
+  "tailwind": {
+    "config": "",
+    "css": "src/app/globals.css",
+    "baseColor": "neutral",
+    "cssVariables": true,
+    "prefix": ""
+  },
+  "iconLibrary": "lucide",
+  "rtl": false,
+  "aliases": {
+    "components": "@/components",
+    "utils": "@/lib/utils",
+    "ui": "@/components/ui",
+    "lib": "@/lib",
+    "hooks": "@/hooks"
+  },
+  "menuColor": "default",
+  "menuAccent": "subtle",
+  "registries": {}
+}

package/apps/web/eslint.config.mjs

@@ -0,0 +1,18 @@
+import { defineConfig, globalIgnores } from "eslint/config";
+import nextVitals from "eslint-config-next/core-web-vitals";
+import nextTs from "eslint-config-next/typescript";
+
+const eslintConfig = defineConfig([
+  ...nextVitals,
+  ...nextTs,
+  // Override default ignores of eslint-config-next.
+  globalIgnores([
+    // Default ignores of eslint-config-next:
+    ".next/**",
+    "out/**",
+    "build/**",
+    "next-env.d.ts",
+  ]),
+]);
+
+export default eslintConfig;

package/apps/web/next.config.ts

@@ -0,0 +1,11 @@
+import path from "node:path";
+import type { NextConfig } from "next";
+
+const nextConfig: NextConfig = {
+  turbopack: {
+    root: path.resolve(__dirname, "../.."),
+  },
+  reactCompiler: true,
+};
+
+export default nextConfig;