auramaxx 1.0.0-alpha.4

package/src/app/api/workspace/config/route.ts

@@ -0,0 +1,106 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { PrismaClient } from '@prisma/client';
+import { requireWorkspaceAdmin } from '../auth';
+
+const prisma = new PrismaClient();
+
+export interface ChainConfig {
+  rpc: string;
+  chainId: number;
+  explorer: string;
+}
+
+export interface AppConfigData {
+  chainOverrides?: Record<string, ChainConfig>;
+}
+
+// GET /api/workspace/config - Get global app configuration
+export async function GET(request: NextRequest) {
+  try {
+    const unauthorized = await requireWorkspaceAdmin(request);
+    if (unauthorized) return unauthorized;
+
+    const config = await prisma.appConfig.findUnique({
+      where: { id: 'global' },
+    });
+
+    if (!config) {
+      return NextResponse.json({
+        success: true,
+        config: { chainOverrides: {} },
+      });
+    }
+
+    const chainConfig = config.chainConfig ? JSON.parse(config.chainConfig) : {};
+
+    return NextResponse.json({
+      success: true,
+      config: {
+        // Handle both old format (direct overrides) and new format (nested)
+        chainOverrides: chainConfig.chainOverrides || chainConfig,
+      },
+    });
+  } catch (error) {
+    console.error('Failed to get app config:', error);
+    return NextResponse.json(
+      { success: false, error: 'Failed to get app config' },
+      { status: 500 }
+    );
+  }
+}
+
+// POST /api/workspace/config - Update global app configuration
+export async function POST(request: NextRequest) {
+  try {
+    const unauthorized = await requireWorkspaceAdmin(request);
+    if (unauthorized) return unauthorized;
+
+    const body = await request.json();
+    const { chainOverrides } = body as AppConfigData;
+
+    // Validate chain overrides if provided
+    if (chainOverrides) {
+      for (const [chain, config] of Object.entries(chainOverrides)) {
+        if (!config.rpc || typeof config.rpc !== 'string') {
+          return NextResponse.json(
+            { success: false, error: `Invalid RPC for chain ${chain}` },
+            { status: 400 }
+          );
+        }
+        if (!config.chainId || typeof config.chainId !== 'number') {
+          return NextResponse.json(
+            { success: false, error: `Invalid chainId for chain ${chain}` },
+            { status: 400 }
+          );
+        }
+      }
+    }
+
+    // Upsert the global config
+    const updated = await prisma.appConfig.upsert({
+      where: { id: 'global' },
+      create: {
+        id: 'global',
+        chainConfig: JSON.stringify(chainOverrides || {}),
+      },
+      update: {
+        chainConfig: JSON.stringify(chainOverrides || {}),
+      },
+    });
+
+    const parsedConfig = updated.chainConfig ? JSON.parse(updated.chainConfig) : {};
+
+    return NextResponse.json({
+      success: true,
+      config: {
+        chainOverrides: parsedConfig,
+      },
+    });
+  } catch (error) {
+    console.error('Failed to update app config:', error);
+    return NextResponse.json(
+      { success: false, error: 'Failed to update app config' },
+      { status: 500 }
+    );
+  }
+}

package/src/app/api/workspace/import/route.ts

@@ -0,0 +1,127 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { PrismaClient } from '@prisma/client';
+import { requireWorkspaceAdmin } from '../auth';
+
+const prisma = new PrismaClient();
+
+interface ImportApp {
+  appType: string;
+  x?: number;
+  y?: number;
+  width?: number;
+  height?: number;
+  zIndex?: number;
+  isVisible?: boolean;
+  isLocked?: boolean;
+  config?: Record<string, unknown>;
+}
+
+interface ImportData {
+  version?: number;
+  workspace: {
+    name: string;
+    slug?: string;
+    icon?: string;
+    order?: number;
+    isDefault?: boolean;
+    isCloseable?: boolean;
+  };
+  apps: ImportApp[];
+}
+
+// POST /api/workspace/import - Import workspace from JSON
+export async function POST(request: NextRequest) {
+  try {
+    const unauthorized = await requireWorkspaceAdmin(request);
+    if (unauthorized) return unauthorized;
+
+    const body: ImportData = await request.json();
+    const { workspace: wsData, apps } = body;
+
+    if (!wsData || !wsData.name) {
+      return NextResponse.json(
+        { success: false, error: 'Invalid import data: workspace name is required' },
+        { status: 400 }
+      );
+    }
+
+    // Generate unique slug
+    const baseSlug = wsData.slug || wsData.name.toLowerCase().replace(/[^a-z0-9]+/g, '-');
+    let slug = baseSlug;
+    let counter = 1;
+
+    while (await prisma.workspace.findUnique({ where: { slug } })) {
+      slug = `${baseSlug}-${counter}`;
+      counter++;
+    }
+
+    // Get next order value
+    const maxOrder = await prisma.workspace.aggregate({
+      _max: { order: true },
+    });
+    const order = wsData.order ?? (maxOrder._max.order ?? -1) + 1;
+
+    // Create workspace
+    const workspace = await prisma.workspace.create({
+      data: {
+        name: wsData.name,
+        slug,
+        icon: wsData.icon,
+        order,
+        isDefault: wsData.isDefault ?? false,
+        isCloseable: wsData.isCloseable ?? true,
+      },
+    });
+
+    // Create apps
+    const createdApps = [];
+    for (const app of apps || []) {
+      const created = await prisma.workspaceApp.create({
+        data: {
+          workspaceId: workspace.id,
+          appType: app.appType,
+          x: app.x ?? 20,
+          y: app.y ?? 20,
+          width: app.width ?? 320,
+          height: app.height ?? 280,
+          zIndex: app.zIndex ?? 10,
+          isVisible: app.isVisible ?? true,
+          isLocked: app.isLocked ?? false,
+          config: app.config ? JSON.stringify(app.config) : null,
+        },
+      });
+      createdApps.push({
+        id: created.id,
+        appType: created.appType,
+        x: created.x,
+        y: created.y,
+        width: created.width,
+        height: created.height,
+        zIndex: created.zIndex,
+        isVisible: created.isVisible,
+        isLocked: created.isLocked,
+        config: created.config ? JSON.parse(created.config) : null,
+      });
+    }
+
+    return NextResponse.json({
+      success: true,
+      workspace: {
+        id: workspace.id,
+        name: workspace.name,
+        slug: workspace.slug,
+        icon: workspace.icon,
+        order: workspace.order,
+        isDefault: workspace.isDefault,
+        isCloseable: workspace.isCloseable,
+      },
+      apps: createdApps,
+    });
+  } catch (error) {
+    console.error('Failed to import workspace:', error);
+    return NextResponse.json(
+      { success: false, error: 'Failed to import workspace' },
+      { status: 500 }
+    );
+  }
+}

package/src/app/api/workspace/route.ts

@@ -0,0 +1,116 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { PrismaClient } from '@prisma/client';
+import { requireWorkspaceAdmin } from './auth';
+
+const prisma = new PrismaClient();
+
+// GET /api/workspace - List all workspaces
+export async function GET(request: NextRequest) {
+  try {
+    const unauthorized = await requireWorkspaceAdmin(request);
+    if (unauthorized) return unauthorized;
+
+    const workspaces = await prisma.workspace.findMany({
+      orderBy: { order: 'asc' },
+      include: {
+        _count: {
+          select: { apps: true },
+        },
+      },
+    });
+
+    return NextResponse.json({
+      success: true,
+      workspaces: workspaces.map((w: any) => ({
+        id: w.id,
+        name: w.name,
+        slug: w.slug,
+        icon: w.icon,
+        order: w.order,
+        isDefault: w.isDefault,
+        isCloseable: w.isCloseable,
+        appCount: w._count.apps,
+        createdAt: w.createdAt.toISOString(),
+        updatedAt: w.updatedAt.toISOString(),
+      })),
+    });
+  } catch (error) {
+    console.error('Failed to list workspaces:', error);
+    return NextResponse.json(
+      { success: false, error: 'Failed to list workspaces' },
+      { status: 500 }
+    );
+  }
+}
+
+// POST /api/workspace - Create a new workspace
+export async function POST(request: NextRequest) {
+  try {
+    const unauthorized = await requireWorkspaceAdmin(request);
+    if (unauthorized) return unauthorized;
+
+    const body = await request.json();
+    const { name, icon, isDefault } = body;
+
+    if (!name) {
+      return NextResponse.json(
+        { success: false, error: 'Name is required' },
+        { status: 400 }
+      );
+    }
+
+    // Generate unique slug
+    const baseSlug = name.toLowerCase().replace(/[^a-z0-9]+/g, '-');
+    let slug = baseSlug;
+    let counter = 1;
+
+    while (await prisma.workspace.findUnique({ where: { slug } })) {
+      slug = `${baseSlug}-${counter}`;
+      counter++;
+    }
+
+    // Get next order value
+    const maxOrder = await prisma.workspace.aggregate({
+      _max: { order: true },
+    });
+    const order = (maxOrder._max.order ?? -1) + 1;
+
+    // If setting as default, unset existing default
+    if (isDefault) {
+      await prisma.workspace.updateMany({
+        where: { isDefault: true },
+        data: { isDefault: false },
+      });
+    }
+
+    const workspace = await prisma.workspace.create({
+      data: {
+        name,
+        slug,
+        icon,
+        order,
+        isDefault: isDefault ?? false,
+        isCloseable: true,
+      },
+    });
+
+    return NextResponse.json({
+      success: true,
+      workspace: {
+        id: workspace.id,
+        name: workspace.name,
+        slug: workspace.slug,
+        icon: workspace.icon,
+        order: workspace.order,
+        isDefault: workspace.isDefault,
+        isCloseable: workspace.isCloseable,
+      },
+    });
+  } catch (error) {
+    console.error('Failed to create workspace:', error);
+    return NextResponse.json(
+      { success: false, error: 'Failed to create workspace' },
+      { status: 500 }
+    );
+  }
+}