ta_data_mas 0.0.2

package/apps/web/src/features/table-editor/table-editor-helpers.server.ts

@@ -0,0 +1,39 @@
+import { redirect } from "next/navigation";
+import apiClient from "@/lib/axios";
+import { retrieveTokenFromCookie } from "@/server-utils/utils";
+import { COOKIE_KEYS } from "@apiDatabase/constants";
+import type { Project } from "@apiDatabase/types";
+
+export async function retrieveTablesFromApi(
+  orgSlug: string,
+  projectSlug: string,
+): Promise<string[]> {
+  const token = await retrieveTokenFromCookie();
+
+  try {
+    const { data } = await apiClient.get<string[]>(
+      `/orgs/${orgSlug}/projects/${projectSlug}/tables`,
+      { headers: { Cookie: `${COOKIE_KEYS.ACCESS_TOKEN}=${token}` } },
+    );
+    return data;
+  } catch {
+    redirect(`/organizations/${orgSlug}/projects`);
+  }
+}
+
+export async function retrieveProjectDbSchema(
+  orgSlug: string,
+  projectSlug: string,
+): Promise<string> {
+  const token = await retrieveTokenFromCookie();
+
+  try {
+    const { data } = await apiClient.get<{ projects: Project }>(
+      `/orgs/${orgSlug}/projects/${projectSlug}`,
+      { headers: { Cookie: `${COOKIE_KEYS.ACCESS_TOKEN}=${token}` } },
+    );
+    return data.projects.dbSchema;
+  } catch {
+    redirect(`/organizations/${orgSlug}/projects`);
+  }
+}

package/apps/web/src/hooks/use-mobile.ts

@@ -0,0 +1,19 @@
+import * as React from "react"
+
+const MOBILE_BREAKPOINT = 768
+
+export function useIsMobile() {
+  const [isMobile, setIsMobile] = React.useState<boolean | undefined>(undefined)
+
+  React.useEffect(() => {
+    const mql = window.matchMedia(`(max-width: ${MOBILE_BREAKPOINT - 1}px)`)
+    const onChange = () => {
+      setIsMobile(window.innerWidth < MOBILE_BREAKPOINT)
+    }
+    mql.addEventListener("change", onChange)
+    setIsMobile(window.innerWidth < MOBILE_BREAKPOINT)
+    return () => mql.removeEventListener("change", onChange)
+  }, [])
+
+  return !!isMobile
+}

package/apps/web/src/lib/axios.ts

@@ -0,0 +1,8 @@
+import axios from "axios";
+
+const apiClient = axios.create({
+  baseURL: process.env.NEXT_PUBLIC_API_URL ?? process.env.API_URL,
+  withCredentials: true,
+});
+
+export default apiClient;

package/apps/web/src/lib/utils.ts

@@ -0,0 +1,6 @@
+import { clsx, type ClassValue } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}

package/apps/web/src/proxy.ts

@@ -0,0 +1,72 @@
+import { NextResponse } from "next/server";
+import type { NextRequest } from "next/server";
+import { COOKIE_KEYS } from "@apiDatabase/constants";
+import * as jose from "jose";
+import { applyAuthCookiesToResponse } from "@/features/auth/cookies";
+
+const AUTH_ROUTES = ["/login", "/register"];
+
+async function refreshSession(
+  refreshToken: string,
+  response: NextResponse,
+): Promise<boolean> {
+  const apiUrl = process.env.API_URL;
+  if (!apiUrl) return false;
+
+  const refreshRes = await fetch(`${apiUrl}/auth/refresh`, {
+    method: "POST",
+    headers: { Cookie: `${COOKIE_KEYS.REFRESH_TOKEN}=${refreshToken}` },
+  });
+
+  if (!refreshRes.ok) return false;
+
+  applyAuthCookiesToResponse(response, refreshRes.headers.getSetCookie());
+  return true;
+}
+
+export async function proxy(request: NextRequest) {
+  const { pathname } = request.nextUrl;
+  const accessToken = request.cookies.get(COOKIE_KEYS.ACCESS_TOKEN)?.value;
+  const refreshToken = request.cookies.get(COOKIE_KEYS.REFRESH_TOKEN)?.value;
+
+  const isAuthRoute = AUTH_ROUTES.some((r) => pathname.startsWith(r));
+  const isProtected =
+    pathname.startsWith("/organizations") || pathname.startsWith("/dashboard");
+
+  let isValid = false;
+  if (accessToken && process.env.JWT_ACCESS_SECRET) {
+    try {
+      const secret = new TextEncoder().encode(process.env.JWT_ACCESS_SECRET);
+      await jose.jwtVerify(accessToken, secret);
+      isValid = true;
+    } catch {
+      // token is expired or invalid: invalid remains false
+    }
+  }
+
+  if (isAuthRoute && isValid) {
+    return NextResponse.redirect(new URL("/dashboard", request.url));
+  }
+
+  if (isAuthRoute && refreshToken) {
+    const response = NextResponse.redirect(new URL("/dashboard", request.url));
+    if (await refreshSession(refreshToken, response)) {
+      return response;
+    }
+  }
+  if (isProtected && !isValid) {
+    if (refreshToken) {
+      const response = NextResponse.next();
+      if (await refreshSession(refreshToken, response)) {
+        return response;
+      }
+    }
+    return NextResponse.redirect(new URL("/login", request.url));
+  }
+
+  return NextResponse.next();
+}
+
+export const config = {
+  matcher: ["/((?!api|_next/static|_next/image|favicon.ico).*)"],
+};

package/apps/web/src/server-utils/utils.ts

@@ -0,0 +1,10 @@
+import { cookies } from "next/headers";
+import { redirect } from "next/navigation";
+import { COOKIE_KEYS } from "@apiDatabase/constants";
+
+export async function retrieveTokenFromCookie(): Promise<string> {
+  const cookieStore = await cookies();
+  const token = cookieStore.get(COOKIE_KEYS.ACCESS_TOKEN)?.value;
+  if (!token) redirect("/login");
+  return token;
+}

package/apps/web/tsconfig.json

@@ -0,0 +1,34 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts",
+    "**/*.mts"
+  ],
+  "exclude": ["node_modules"]
+}

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "ta_data_mas",
+  "private": false,
+  "version": "0.0.2",
+  "license": "MIT",
+  "keywords": [
+    "API's",
+    "Postgres SQL",
+    "data"
+  ],
+  "scripts": {
+    "dev:api": "pnpm --filter api run start:dev",
+    "dev:web": "pnpm --filter web run dev",
+    "dev": "concurrently \"pnpm run dev:api\" \"pnpm run dev:web\"",
+    "build": "pnpm -r --if-present run build",
+    "test": "pnpm --filter api test"
+  },
+  "packageManager": "pnpm@11.17.0",
+  "devDependencies": {
+    "concurrently": "^10.0.5"
+  }
+}

package/packages/apiDatabase-js/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "ta_data_mas-js",
+  "version": "1.0.0",
+  "description": "The official Javascript SDK for Api_Database",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch"
+  },
+  "keywords": [
+    "backend",
+    "database",
+    "realtime",
+    "auth",
+    "storage"
+  ],
+  "author": "argyrios",
+  "license": "ISC",
+  "type": "module",
+  "dependencies": {
+    "@apiDatabase/constants": "workspace:*",
+    "socket.io-client": "^4.8.3",
+    "uploadthing": "^7.7.4"
+  },
+  "devDependencies": {
+    "@apiDatabase/types": "workspace:*",
+    "tsdown": "^0.22.14",
+    "typescript": "^6.0.3"
+  }
+}

package/packages/apiDatabase-js/src/auth/index.ts

@@ -0,0 +1,121 @@
+interface AuthUser {
+  id: string;
+  email: string;
+}
+
+export interface AuthResult {
+  data: { user: AuthUser; accessToken: string } | null;
+  error: string | null;
+}
+
+export class ApiDatabaseAuth {
+  private currentToken: string | null = null;
+
+  constructor(private projectUrl: string) {}
+
+  async signUp(credentials: {
+    email: string;
+    password: string;
+  }): Promise<AuthResult> {
+    try {
+      const res = await fetch(`${this.projectUrl}/auth/signup`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(credentials),
+      });
+
+      if (!res.ok) {
+        const err = (await res.json().catch(() => ({}))) as {
+          message?: string;
+        };
+        return { data: null, error: err.message ?? "Sign up failed" };
+      }
+
+      const data = (await res.json()) as {
+        user: AuthUser;
+        accessToken: string;
+      };
+      this.currentToken = data.accessToken;
+      return { data, error: null };
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : "Network error";
+      return { data: null, error: message };
+    }
+  }
+
+  async signIn(credentials: {
+    email: string;
+    password: string;
+  }): Promise<AuthResult> {
+    try {
+      const res = await fetch(`${this.projectUrl}/auth/signin`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(credentials),
+      });
+
+      if (!res.ok) {
+        const err = (await res.json().catch(() => ({}))) as {
+          message?: string;
+        };
+        return { data: null, error: err.message ?? "Sign in failed" };
+      }
+
+      const data = (await res.json()) as {
+        user: AuthUser;
+        accessToken: string;
+      };
+      this.currentToken = data.accessToken;
+      return { data, error: null };
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : "Network error";
+      return { data: null, error: message };
+    }
+  }
+
+  async sendMagicLink(email: string): Promise<{ error: string | null }> {
+    try {
+      const res = await fetch(`${this.projectUrl}/auth/magic-link`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ email }),
+      });
+
+      if (!res.ok) return { error: "Failed to send magic link" };
+      return { error: null };
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : "Network error";
+      return { error: message };
+    }
+  }
+
+  signInWithGoogle(): void {
+    window.location.href = `${this.projectUrl}/auth/google`;
+  }
+
+  signInWithGithub(): void {
+    window.location.href = `${this.projectUrl}/auth/github`;
+  }
+
+  signOut(): void {
+    this.currentToken = null;
+  }
+
+  getUser(): AuthUser | null {
+    if (!this.currentToken) return null;
+
+    try {
+      const payload = JSON.parse(atob(this.currentToken.split(".")[1])) as {
+        sub: string;
+        email: string;
+      };
+      return { id: payload.sub, email: payload.email };
+    } catch {
+      return null;
+    }
+  }
+
+  getAccessToken(): string | null {
+    return this.currentToken;
+  }
+}

package/packages/apiDatabase-js/src/client.ts

@@ -0,0 +1,25 @@
+import { ApiDatabaseDb } from "./db";
+import { apiDatabaseRealtime } from "./realtime";
+import { ApiDatabaseStorage } from "./storage";
+import { ApiDatabaseAuth } from "./auth";
+
+export class ApiDatabaseClient {
+  readonly db: ApiDatabaseDb;
+  readonly realtime: apiDatabaseRealtime;
+  readonly storage: ApiDatabaseStorage;
+  readonly auth: ApiDatabaseAuth;
+
+  constructor(
+    private projectUrl: string,
+    private apiKey: string,
+  ) {
+    this.db = new ApiDatabaseDb(projectUrl, apiKey);
+    this.realtime = new apiDatabaseRealtime(projectUrl, apiKey);
+    this.storage = new ApiDatabaseStorage(projectUrl, apiKey);
+    this.auth = new ApiDatabaseAuth(projectUrl);
+  }
+
+  from<T = Record<string, unknown>>(table: string) {
+    return this.db.from<T>(table);
+  }
+}

package/packages/apiDatabase-js/src/db/index.ts

@@ -0,0 +1,15 @@
+import { QueryBuilder } from "./query-builder";
+
+export class ApiDatabaseDb {
+  constructor(
+    private projectUrl: string,
+    private apiKey: string,
+  ) {}
+
+  from<T = Record<string, unknown>>(table: string): QueryBuilder<T> {
+    return new QueryBuilder<T>(this.projectUrl, table, this.apiKey);
+  }
+}
+
+export { QueryBuilder } from "./query-builder";
+export type { QueryResult } from "./query-builder";

package/packages/apiDatabase-js/src/db/query-builder.ts

@@ -0,0 +1,194 @@
+export type HttpMethod = "GET" | "POST" | "PATCH" | "DELETE";
+
+interface FilterClause {
+  column: string;
+  operator: string;
+  value: string;
+}
+
+export interface QueryResult<T> {
+  data: T | null;
+  error: string | null;
+}
+
+export class QueryBuilder<T = Record<string, unknown>> {
+  private _method: HttpMethod = "GET";
+  private _body: Record<string, unknown> | null = null;
+  private _filters: FilterClause[] = [];
+  private _selectColumns: string[] = [];
+  private _orderCol: string | null = null;
+  private _orderDir: "asc" | "desc" = "asc";
+  private _limitVal: number | null = null;
+  private _offsetVal: number | null = null;
+
+  constructor(
+    private projectUrl: string,
+    private table: string,
+    private apiKey: string,
+  ) {}
+
+  select(columns = "*"): this {
+    this._selectColumns =
+      columns === "*" ? [] : columns.split(",").map((c) => c.trim());
+    return this;
+  }
+
+  eq(column: string, value: unknown): this {
+    this._filters.push({ column, operator: "eq", value: String(value) });
+    return this;
+  }
+
+  neq(column: string, value: unknown): this {
+    this._filters.push({ column, operator: "neq", value: String(value) });
+    return this;
+  }
+
+  gt(column: string, value: unknown): this {
+    this._filters.push({ column, operator: "gt", value: String(value) });
+    return this;
+  }
+
+  gte(column: string, value: unknown): this {
+    this._filters.push({ column, operator: "gte", value: String(value) });
+    return this;
+  }
+
+  lt(column: string, value: unknown): this {
+    this._filters.push({ column, operator: "lt", value: String(value) });
+    return this;
+  }
+
+  lte(column: string, value: unknown): this {
+    this._filters.push({ column, operator: "lte", value: String(value) });
+    return this;
+  }
+
+  like(column: string, pattern: string): this {
+    this._filters.push({ column, operator: "like", value: pattern });
+    return this;
+  }
+
+  ilike(column: string, pattern: string): this {
+    this._filters.push({ column, operator: "ilike", value: pattern });
+    return this;
+  }
+
+  is(column: string, value: "null" | "not null"): this {
+    this._filters.push({
+      column,
+      operator: "is",
+      value: value === "null" ? "null" : "not null",
+    });
+    return this;
+  }
+
+  order(column: string, direction: "asc" | "desc" = "asc"): this {
+    this._orderCol = column;
+    this._orderDir = direction;
+    return this;
+  }
+
+  limit(n: number): this {
+    this._limitVal = n;
+    return this;
+  }
+
+  offset(n: number): this {
+    this._offsetVal = n;
+    return this;
+  }
+
+  insert(data: Record<string, unknown>): this {
+    this._method = "POST";
+    this._body = data;
+    return this;
+  }
+
+  update(data: Record<string, unknown>): this {
+    this._method = "PATCH";
+    this._body = data;
+    return this;
+  }
+
+  delete(): this {
+    this._method = "DELETE";
+    return this;
+  }
+
+  private getRowIdForMutation(): string {
+    const idFilter = this._filters.find(
+      (f) => f.column === "id" && f.operator === "eq",
+    );
+    if (!idFilter) {
+      throw new Error(
+        'update() and delete() require .eq("id", rowId) before executing',
+      );
+    }
+    return idFilter.value;
+  }
+
+  private buildUrl(): string {
+    const base = `${this.projectUrl}/rest/${this.table}`;
+
+    if (this._method === "PATCH" || this._method === "DELETE") {
+      return `${base}/${this.getRowIdForMutation()}`;
+    }
+
+    const params = new URLSearchParams();
+
+    if (this._selectColumns.length > 0) {
+      params.set("select", this._selectColumns.join(","));
+    }
+
+    for (const { column, operator, value } of this._filters) {
+      params.set(column, `${operator}.${value}`);
+    }
+
+    if (this._orderCol) {
+      params.set("order", `${this._orderCol}.${this._orderDir}`);
+    }
+
+    if (this._limitVal !== null) params.set("limit", String(this._limitVal));
+    if (this._offsetVal !== null) params.set("offset", String(this._offsetVal));
+
+    const query = params.toString();
+    return query ? `${base}?${query}` : base;
+  }
+
+  async execute(): Promise<QueryResult<T | T[]>> {
+    try {
+      const res = await fetch(this.buildUrl(), {
+        method: this._method,
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`,
+          "Content-Type": "application/json",
+        },
+        body: this._body ? JSON.stringify(this._body) : undefined,
+      });
+
+      if (!res.ok) {
+        const err = (await res.json().catch(() => ({}))) as {
+          message?: string;
+        };
+        return { data: null, error: err.message ?? `HTTP ${res.status}` };
+      }
+
+      if (res.status === 204) return { data: null, error: null };
+
+      const data = (await res.json()) as T | T[];
+      return { data, error: null };
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : "Network error";
+      return { data: null, error: message };
+    }
+  }
+
+  then<TResult1 = QueryResult<T | T[]>, TResult2 = never>(
+    onfulfilled?:
+      | ((value: QueryResult<T | T[]>) => TResult1 | PromiseLike<TResult1>)
+      | null,
+    onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null,
+  ): Promise<TResult1 | TResult2> {
+    return this.execute().then(onfulfilled, onrejected);
+  }
+}

package/packages/apiDatabase-js/src/index.ts

@@ -0,0 +1,16 @@
+import { ApiDatabaseClient } from "./client";
+
+export function createClient(
+  projectUrl: string,
+  apiKey: string,
+): ApiDatabaseClient {
+  return new ApiDatabaseClient(projectUrl, apiKey);
+}
+
+export { ApiDatabaseClient } from "./client";
+export { QueryBuilder, ApiDatabaseDb } from "./db";
+export type { QueryResult } from "./db";
+export { apiDatabaseRealtime } from "./realtime";
+export type { RealtimeCallback } from "./realtime";
+export { ApiDatabaseStorage } from "./storage";
+export { ApiDatabaseAuth } from "./auth";