ta_data_mas 0.0.2

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

@@ -0,0 +1,84 @@
+import { io, type Socket } from "socket.io-client";
+import { REALTIME_EVENTS } from "@apiDatabase/constants";
+import type { RealtimeEvent } from "@apiDatabase/types";
+
+export type RealtimeCallback = (event: RealtimeEvent) => void;
+
+function getRealtimeSocketUrl(projectUrl: string): string {
+  const origin = new URL(projectUrl).origin;
+  // NestJS gateway namespace is /realtime on the API host, NOT under /api
+  return `${origin}/realtime`;
+}
+
+export class apiDatabaseRealtime {
+  private socket: Socket | null = null;
+  private callbacks = new Map<string, Set<RealtimeCallback>>();
+
+  constructor(
+    private projectUrl: string,
+    private apiKey: string,
+  ) {}
+
+  private connect(): Socket {
+    if (this.socket?.connected) return this.socket;
+
+    this.socket = io(getRealtimeSocketUrl(this.projectUrl), {
+      auth: { token: this.apiKey },
+      transports: ["websocket", "polling"],
+    });
+
+    this.socket.on("connect", () => {
+      for (const table of this.callbacks.keys()) {
+        this.socket?.emit(REALTIME_EVENTS.SUBSCRIBE, table);
+      }
+    });
+
+    this.socket.on(REALTIME_EVENTS.EVENT, (event: RealtimeEvent) => {
+      const handlers = this.callbacks.get(event.table);
+      handlers?.forEach((cb) => cb(event));
+    });
+
+    this.socket.on(REALTIME_EVENTS.ERROR, (msg: string) => {
+      console.error("[apiDatabase-js] realtime error:", msg);
+    });
+
+    return this.socket;
+  }
+
+  subscribe(table: string, callback: RealtimeCallback): () => void {
+    const socket = this.connect();
+
+    if (!this.callbacks.has(table)) {
+      this.callbacks.set(table, new Set());
+      socket.emit(REALTIME_EVENTS.SUBSCRIBE, table);
+    }
+
+    this.callbacks.get(table)!.add(callback);
+
+    return () => this.unsubscribe(table, callback);
+  }
+
+  unsubscribe(table: string, callback?: RealtimeCallback): void {
+    if (!callback) {
+      this.callbacks.delete(table);
+      this.socket?.emit(REALTIME_EVENTS.UNSUBSCRIBE, table);
+      return;
+    }
+
+    const handlers = this.callbacks.get(table);
+    if (!handlers) return;
+
+    handlers.delete(callback);
+
+    if (handlers.size === 0) {
+      this.callbacks.delete(table);
+      this.socket?.emit(REALTIME_EVENTS.UNSUBSCRIBE, table);
+    }
+  }
+
+  disconnect(): void {
+    this.socket?.disconnect();
+    this.socket = null;
+    this.callbacks.clear();
+  }
+}

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

@@ -0,0 +1,130 @@
+import { genUploader } from "uploadthing/client";
+import type { StorageObject } from "@apiDatabase/types";
+
+type StorageUploadRouter = {
+  bucketUploader: {
+    input: undefined;
+    output: null;
+  };
+};
+
+export interface StorageResult<T> {
+  data: T | null;
+  error: string | null;
+}
+
+async function apiFetch<T>(
+  url: string,
+  apiKey: string,
+  init?: RequestInit,
+): Promise<StorageResult<T>> {
+  try {
+    const res = await fetch(url, {
+      ...init,
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json",
+        ...init?.headers,
+      },
+    });
+
+    if (!res.ok) {
+      const err = (await res.json().catch(() => ({}))) as { message?: string };
+      return { data: null, error: err.message ?? `HTTP ${res.status}` };
+    }
+
+    const data = (await res.json()) as T;
+    return { data, error: null };
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : "Network error";
+    return { data: null, error: message };
+  }
+}
+
+export class StorageBucketRef {
+  constructor(
+    private projectUrl: string,
+    private apiKey: string,
+    private bucketName: string,
+  ) {}
+
+  private storageBase(): string {
+    const bucket = encodeURIComponent(this.bucketName);
+    return `${this.projectUrl}/storage/buckets/${bucket}`;
+  }
+
+  async list(): Promise<StorageResult<StorageObject[]>> {
+    return apiFetch<StorageObject[]>(
+      `${this.storageBase()}/objects`,
+      this.apiKey,
+    );
+  }
+
+  async upload(file: File): Promise<StorageResult<StorageObject>> {
+    try {
+      const uploadUrl = `${this.storageBase()}/upload`;
+      const { uploadFiles } = genUploader({
+        url: uploadUrl,
+      });
+
+      const uploaded = await uploadFiles("bucketUploader", {
+        files: [file],
+        headers: { Authorization: `Bearer ${this.apiKey}` },
+      });
+
+      const utFile = uploaded[0];
+      if (!utFile) {
+        return { data: null, error: "Upload returned no files" };
+      }
+
+      return apiFetch<StorageObject>(
+        `${this.storageBase()}/objects`,
+        this.apiKey,
+        {
+          method: "POST",
+          body: JSON.stringify({
+            name: utFile.name,
+            size: utFile.size,
+            type: file.type || "application/octet-stream",
+            utKey: utFile.key,
+            url: utFile.url,
+          }),
+        },
+      );
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : "Upload failed";
+      return { data: null, error: message };
+    }
+  }
+
+  async remove(objectId: string): Promise<StorageResult<{ message: string }>> {
+    return apiFetch<{ message: string }>(
+      `${this.projectUrl}/storage/objects/${objectId}`,
+      this.apiKey,
+      { method: "DELETE" },
+    );
+  }
+
+  async getSignedUrl(
+    objectId: string,
+  ): Promise<StorageResult<{ url: string }>> {
+    return apiFetch<{ url: string }>(
+      `${this.projectUrl}/storage/objects/${objectId}/signed-url`,
+      this.apiKey,
+    );
+  }
+}
+
+export class ApiDatabaseStorage {
+  constructor(
+    private projectUrl: string,
+    private apiKey: string,
+  ) {}
+
+  from(bucketName: string): StorageBucketRef {
+    return new StorageBucketRef(this.projectUrl, this.apiKey, bucketName);
+  }
+}
+
+// const bucket = supabavolt.storage.from('test');
+// const {data: files} = await bucket.list();

package/packages/apiDatabase-js/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "outDir": "./dist"
+  },
+  "include": ["src"]
+}

package/packages/apiDatabase-js/tsdown.config.ts

@@ -0,0 +1,20 @@
+import { defineConfig } from "tsdown";
+
+export default defineConfig({
+  entry: ["src/index.ts"],
+  format: ["cjs", "esm"],
+  platform: "browser",
+  dts: true,
+  clean: true,
+  sourcemap: true,
+  minify: false,
+  deps: {
+    neverBundle: ["@apiDatabase/types"],
+    alwaysBundle: [
+      "socket.io-client",
+      "@apiDatabase/constants",
+      "uploadthing",
+      "uploadthing/client",
+    ],
+  },
+});

package/packages/constants/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "@apiDatabase/constants",
+  "version": "0.0.1",
+  "private": true,
+  "main": "./src/index.ts"
+}

package/packages/constants/src/index.ts

@@ -0,0 +1,76 @@
+export const COOKIE_KEYS = {
+  ACCESS_TOKEN: "access_token",
+  REFRESH_TOKEN: "refresh_token",
+} as const;
+
+export const ORG_ROLES = {
+  ADMIN: "admin",
+  DEVELOPER: "developer",
+} as const;
+
+export const INVITE_EXPIRES_IN = "24h";
+
+export const PROJECT_KEY_ROLES = {
+  ANON: "anon",
+  SERVICE_ROLE: "service_role",
+} as const;
+
+export const COLUMN_TYPES = [
+  "text",
+  "integer",
+  "bigint",
+  "boolean",
+  "timestamp",
+  "uuid",
+  "jsonb",
+  "numeric",
+] as const;
+
+export const TABLE_EDITOR_INTENT = {
+  CREATE_TABLE: "CREATE_TABLE",
+  DELETE_TABLE: "DELETE_TABLE",
+  FETCH_TABLE: "FETCH_TABLE",
+  ADD_COLUMN: "ADD_COLUMN",
+} as const;
+
+export type TableEditorIntent =
+  (typeof TABLE_EDITOR_INTENT)[keyof typeof TABLE_EDITOR_INTENT];
+
+export const RESERVED_QUERY_PARAMS = new Set([
+  "select",
+  "order",
+  "limit",
+  "offset",
+]);
+
+export const FILTER_OPERATORS = {
+  eq: "=",
+  neq: "!=",
+  gt: ">",
+  gte: ">=",
+  lt: "<",
+  lte: "<=",
+  like: "LIKE",
+  ilike: "ILIKE",
+  is: "IS",
+} as const;
+
+export type FilterOperator = keyof typeof FILTER_OPERATORS;
+
+// REALTIME
+export const REALTIME_EVENTS = {
+  SUBSCRIBE: "subscribe",
+  UNSUBSCRIBE: "unsubscribe",
+  EVENT: "event",
+  ERROR: "error",
+} as const;
+
+// ─── Project Auth ─────────────────────────────────────────────────────────────
+
+export const AUTH_PROVIDERS = {
+  EMAIL: "email",
+  GOOGLE: "google",
+  GITHUB: "github",
+} as const;
+
+export const MAGIC_LINK_EXPIRES_IN = "15m";

package/packages/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "outDir": "./dist"
+  },
+  "include": ["src"]
+}

package/packages/tsdown.config.ts

@@ -0,0 +1,20 @@
+import { defineConfig } from "tsdown";
+
+export default defineConfig({
+  entry: ["src/index.ts"],
+  format: ["cjs", "esm"],
+  platform: "browser",
+  dts: true,
+  clean: true,
+  sourcemap: true,
+  minify: false,
+  deps: {
+    neverBundle: ["@apiDatabase/types"],
+    alwaysBundle: [
+      "socket.io-client",
+      "@apiDatabase/constants",
+      "uploadthing",
+      "uploadthing/client",
+    ],
+  },
+});

package/packages/types/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "@apiDatabase/types",
+  "version": "0.0.1",
+  "private": true,
+  "main": "./src/index.ts"
+}

package/packages/types/src/index.ts

@@ -0,0 +1,254 @@
+export interface User {
+  id: string;
+  email: string;
+  name: string | null;
+  avatarUrl: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export type OrgRole = "admin" | "developer";
+
+export interface Organization {
+  id: string;
+  name: string;
+  slug: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface OrgMember {
+  id: string;
+  orgId: string;
+  userId: string;
+  role: OrgRole;
+  createdAt: string;
+}
+
+export interface Project {
+  id: string;
+  orgId: string;
+  name: string;
+  slug: string;
+  dbSchema: string;
+  projectUrl: string;
+  anonKey: string;
+  serviceRoleKey: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface RegisterInput {
+  email: string;
+  password: string;
+  name: string;
+}
+
+export interface LoginInput {
+  email: string;
+  password: string;
+}
+
+export interface AuthTokens {
+  accessToken: string;
+  refreshToken: string;
+}
+
+export interface JwtPayload {
+  sub: string;
+  email: string;
+}
+
+export interface CreateOrgInput {
+  name: string;
+}
+
+export interface OrganizationWithMeta extends Organization {
+  memberCount: number;
+  projectCount: number;
+  role: OrgRole;
+}
+
+export interface OrgMemberWithUser {
+  id: string;
+  role: OrgRole;
+  createdAt: string;
+  user: {
+    id: string;
+    name: string | null;
+    email: string;
+    avatarUrl: string | null;
+  };
+}
+
+export interface InviteMemberInput {
+  email: string;
+}
+
+export interface UpdateRoleInput {
+  role: OrgRole;
+}
+
+export interface CreateProjectInput {
+  name: string;
+}
+
+export interface ProjectWithOrg extends Project {
+  org: Pick<Organization, "id" | "name" | "slug">;
+}
+
+export type ColumnType =
+  | "text"
+  | "integer"
+  | "bigint"
+  | "boolean"
+  | "timestamp"
+  | "uuid"
+  | "jsonb"
+  | "numeric"
+  | "array";
+
+export interface TableColumn {
+  name: string;
+  type: ColumnType;
+  isNullable: boolean;
+  isPrimaryKey: boolean;
+  defaultValue: string | null;
+  foreignKey: {
+    table: string;
+    column: string;
+  } | null;
+}
+
+export interface TableInfo {
+  name: string;
+  columns: TableColumn[];
+}
+
+export interface CreateColumnInput {
+  name: string;
+  type: ColumnType;
+  isNullable: boolean;
+  isPrimaryKey: boolean;
+  defaultValue?: string;
+  foreignKeyTable?: string;
+  foreignKeyColumn?: string;
+}
+
+export interface CreateTableInput {
+  name: string;
+  columns: CreateColumnInput[];
+}
+
+// API DOCS
+export interface ProjectApiEndpoint {
+  method: "GET" | "POST" | "PATCH" | "DELETE";
+  path: string;
+  description: string;
+  example: string;
+}
+
+export interface ProjectApiDocs {
+  projectUrl: string;
+  anonKey: string;
+  serviceRoleKey: string;
+  tables: {
+    name: string;
+    endpoints: ProjectApiEndpoint[];
+  }[];
+}
+
+export interface ProjectBySlugResponse {
+  projects: Project;
+  organizations: Organization;
+  org_members: OrgMember;
+}
+// SQL EDITOR
+export interface QueryResult {
+  rows: Record<string, unknown>[];
+  columns: string[];
+  rowCount: number;
+  executionTimeMs: number;
+  command?: string;
+}
+
+export interface QueryHistoryItem {
+  id: string;
+  projectId: string;
+  sql: string;
+  executionTimeMs: number;
+  rowCount: number;
+  createdAt: string;
+}
+
+export type RealtimeEventType = "INSERT" | "UPDATE" | "DELETE";
+
+export interface RealtimeEvent {
+  type: RealtimeEventType;
+  table: string;
+  record: Record<string, unknown>;
+  oldRecord?: Record<string, unknown>; // only on UPDATE and DELETE
+  projectId: string;
+  timestamp: string;
+}
+
+export type BucketAccess = "public" | "private";
+
+export interface StorageBucket {
+  id: string;
+  projectId: string;
+  name: string;
+  access: BucketAccess;
+  createdAt: string;
+}
+
+export interface StorageObject {
+  id: string;
+  bucketId: string;
+  name: string;
+  size: number;
+  mimeType: string;
+  utKey: string; // UploadThing file key — used to delete or get signed URL
+  url: string; // public URL (public buckets) or empty string (private)
+  createdAt: string;
+}
+
+export interface CreateBucketInput {
+  name: string;
+  access: BucketAccess;
+}
+
+export interface ProjectAuthUser {
+  id: string;
+  email: string;
+  emailVerified: boolean;
+  provider: "email" | "google" | "github";
+  createdAt: string;
+}
+
+export interface SignUpInput {
+  email: string;
+  password: string;
+}
+
+export interface SignInInput {
+  email: string;
+  password: string;
+}
+
+export interface MagicLinkInput {
+  email: string;
+}
+
+export interface ProjectOAuthSettings {
+  siteUrl: string | null;
+  googleClientId: string | null;
+  googleClientSecret: string | null;
+  githubClientId: string | null;
+  githubClientSecret: string | null;
+}
+
+export interface ProjectAuthResponse {
+  user: { id: string; email: string };
+  accessToken: string;
+}

package/pnpm-workspace.yaml

@@ -0,0 +1,10 @@
+packages:
+  - "apps/*"
+  - "packages/*"
+allowBuilds:
+  '@parcel/watcher': true
+  bcrypt: true
+  esbuild: true
+  msgpackr-extract: false
+  sharp: true
+  unrs-resolver: true