@useatlas/create 0.0.6 → 0.0.7

package/templates/docker/src/api/routes/prompts.ts

@@ -0,0 +1,221 @@
+/**
+ * Public prompt library API routes.
+ *
+ * Mounted at /api/v1/prompts. Available to all authenticated users (not admin-gated).
+ * Provides read-only access to prompt collections and items, enabling the
+ * prompt library UI. Returns built-in collections plus any belonging to the
+ * user's organization.
+ */
+
+import { OpenAPIHono, createRoute } from "@hono/zod-openapi";
+import { Effect } from "effect";
+import { runEffect } from "@atlas/api/lib/effect/hono";
+import { AuthContext } from "@atlas/api/lib/effect/services";
+import { validationHook } from "./validation-hook";
+import { z } from "zod";
+import { hasInternalDB, internalQuery } from "@atlas/api/lib/db/internal";
+import type { PromptCollection, PromptItem } from "@useatlas/types";
+import { ErrorSchema } from "./shared-schemas";
+import { standardAuth, requestContext, type AuthEnv } from "./middleware";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function toPromptCollection(row: Record<string, unknown>): PromptCollection {
+  return {
+    id: row.id as string,
+    orgId: (row.org_id as string) ?? null,
+    name: row.name as string,
+    industry: row.industry as string,
+    description: (row.description as string) ?? "",
+    isBuiltin: row.is_builtin as boolean,
+    sortOrder: row.sort_order as number,
+    createdAt: String(row.created_at),
+    updatedAt: String(row.updated_at),
+  };
+}
+
+function toPromptItem(row: Record<string, unknown>): PromptItem {
+  return {
+    id: row.id as string,
+    collectionId: row.collection_id as string,
+    question: row.question as string,
+    description: (row.description as string) ?? null,
+    category: (row.category as string) ?? null,
+    sortOrder: row.sort_order as number,
+    createdAt: String(row.created_at),
+    updatedAt: String(row.updated_at),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Schemas
+// ---------------------------------------------------------------------------
+
+
+// ---------------------------------------------------------------------------
+// Route definitions
+// ---------------------------------------------------------------------------
+
+const listCollectionsRoute = createRoute({
+  method: "get",
+  path: "/",
+  tags: ["Prompts"],
+  summary: "List prompt collections",
+  description:
+    "Returns prompt collections available to the current user: built-in collections plus any belonging to the user's organization.",
+  responses: {
+    200: {
+      description: "List of prompt collections",
+      content: {
+        "application/json": {
+          schema: z.object({ collections: z.array(z.record(z.string(), z.unknown())) }),
+        },
+      },
+    },
+    401: {
+      description: "Authentication required",
+      content: { "application/json": { schema: z.record(z.string(), z.unknown()) } },
+    },
+    403: {
+      description: "Forbidden — insufficient permissions",
+      content: { "application/json": { schema: z.record(z.string(), z.unknown()) } },
+    },
+    429: {
+      description: "Rate limit exceeded",
+      content: { "application/json": { schema: z.record(z.string(), z.unknown()) } },
+    },
+    500: {
+      description: "Internal server error",
+      content: { "application/json": { schema: ErrorSchema } },
+    },
+  },
+});
+
+const getCollectionRoute = createRoute({
+  method: "get",
+  path: "/{id}",
+  tags: ["Prompts"],
+  summary: "Get prompt collection with items",
+  description:
+    "Returns a single prompt collection with all its items, ordered by sort_order.",
+  request: {
+    params: z.object({
+      id: z.string().openapi({ param: { name: "id", in: "path" }, example: "collection-id" }),
+    }),
+  },
+  responses: {
+    200: {
+      description: "Collection with items",
+      content: {
+        "application/json": {
+          schema: z.object({
+            collection: z.record(z.string(), z.unknown()),
+            items: z.array(z.record(z.string(), z.unknown())),
+          }),
+        },
+      },
+    },
+    401: {
+      description: "Authentication required",
+      content: { "application/json": { schema: z.record(z.string(), z.unknown()) } },
+    },
+    403: {
+      description: "Forbidden — insufficient permissions",
+      content: { "application/json": { schema: z.record(z.string(), z.unknown()) } },
+    },
+    404: {
+      description: "Prompt collection not found",
+      content: { "application/json": { schema: ErrorSchema } },
+    },
+    429: {
+      description: "Rate limit exceeded",
+      content: { "application/json": { schema: z.record(z.string(), z.unknown()) } },
+    },
+    500: {
+      description: "Internal server error",
+      content: { "application/json": { schema: ErrorSchema } },
+    },
+  },
+});
+
+// ---------------------------------------------------------------------------
+// Router
+// ---------------------------------------------------------------------------
+
+export const prompts = new OpenAPIHono<AuthEnv>({ defaultHook: validationHook });
+
+prompts.use(standardAuth);
+prompts.use(requestContext);
+
+// ---------------------------------------------------------------------------
+// GET / — list collections (built-in + user's org)
+// ---------------------------------------------------------------------------
+
+prompts.openapi(listCollectionsRoute, async (c) => {
+  return runEffect(c, Effect.gen(function* () {
+    const { orgId } = yield* AuthContext;
+
+    if (!hasInternalDB()) {
+      return c.json({ collections: [] }, 200);
+    }
+
+    let rows: Record<string, unknown>[];
+    if (orgId) {
+      rows = yield* Effect.promise(() => internalQuery<Record<string, unknown>>(
+        `SELECT * FROM prompt_collections WHERE org_id IS NULL OR org_id = $1 ORDER BY sort_order ASC, created_at ASC`,
+        [orgId],
+      ));
+    } else {
+      rows = yield* Effect.promise(() => internalQuery<Record<string, unknown>>(
+        `SELECT * FROM prompt_collections WHERE org_id IS NULL ORDER BY sort_order ASC, created_at ASC`,
+      ));
+    }
+
+    return c.json({ collections: rows.map(toPromptCollection) }, 200);
+  }), { label: "list prompt collections" });
+});
+
+// ---------------------------------------------------------------------------
+// GET /:id — collection detail with items
+// ---------------------------------------------------------------------------
+
+prompts.openapi(getCollectionRoute, async (c) => {
+  return runEffect(c, Effect.gen(function* () {
+    const { orgId } = yield* AuthContext;
+
+    if (!hasInternalDB()) {
+      return c.json({ error: "not_found", message: "Prompt collection not found." }, 404);
+    }
+
+    const { id } = c.req.valid("param");
+
+    let collectionRows: Record<string, unknown>[];
+    if (orgId) {
+      collectionRows = yield* Effect.promise(() => internalQuery<Record<string, unknown>>(
+        `SELECT * FROM prompt_collections WHERE id = $1 AND (org_id IS NULL OR org_id = $2)`,
+        [id, orgId],
+      ));
+    } else {
+      collectionRows = yield* Effect.promise(() => internalQuery<Record<string, unknown>>(
+        `SELECT * FROM prompt_collections WHERE id = $1 AND org_id IS NULL`,
+        [id],
+      ));
+    }
+
+    if (collectionRows.length === 0) {
+      return c.json({ error: "not_found", message: "Prompt collection not found." }, 404);
+    }
+
+    const items = yield* Effect.promise(() => internalQuery<Record<string, unknown>>(
+      `SELECT * FROM prompt_items WHERE collection_id = $1 ORDER BY sort_order ASC, created_at ASC`,
+      [id],
+    ));
+
+    return c.json({
+      collection: toPromptCollection(collectionRows[0]),
+      items: items.map(toPromptItem),
+    }, 200);
+  }), { label: "get prompt collection" });
+});

package/templates/docker/src/api/routes/public-branding.ts

@@ -0,0 +1,106 @@
+/**
+ * Public workspace branding route.
+ *
+ * Mounted at /api/v1/branding. Returns branding for the current workspace
+ * without requiring admin access. Used by the frontend and widget to load
+ * branding. Attempts to resolve org from session; returns null branding if
+ * no session or no org context.
+ */
+
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import { validationHook } from "./validation-hook";
+import { createLogger } from "@atlas/api/lib/logger";
+import { authenticateRequest } from "@atlas/api/lib/auth/middleware";
+import { getWorkspaceBrandingPublic } from "@atlas/ee/branding/white-label";
+import { runHandler } from "@atlas/api/lib/effect/hono";
+import { withRequestId, type AuthEnv } from "./middleware";
+import { ErrorSchema } from "./shared-schemas";
+
+const log = createLogger("public-branding");
+
+// ---------------------------------------------------------------------------
+// Schemas
+// ---------------------------------------------------------------------------
+
+const PublicBrandingSchema = z.object({
+  logoUrl: z.string().nullable(),
+  logoText: z.string().nullable(),
+  primaryColor: z.string().nullable(),
+  faviconUrl: z.string().nullable(),
+  hideAtlasBranding: z.boolean(),
+});
+
+// ---------------------------------------------------------------------------
+// Route definition
+// ---------------------------------------------------------------------------
+
+const getBrandingRoute = createRoute({
+  method: "get",
+  path: "/",
+  tags: ["Branding"],
+  summary: "Get workspace branding (public)",
+  description:
+    "Returns the workspace's custom branding for the current session. " +
+    "No admin role required. Returns null branding if no custom branding is set.",
+  responses: {
+    200: {
+      description: "Workspace branding (null if using Atlas defaults)",
+      content: {
+        "application/json": {
+          schema: z.object({ branding: PublicBrandingSchema.nullable() }),
+        },
+      },
+    },
+    500: {
+      description: "Internal server error",
+      content: { "application/json": { schema: ErrorSchema } },
+    },
+  },
+});
+
+// ---------------------------------------------------------------------------
+// Router
+// ---------------------------------------------------------------------------
+
+const publicBranding = new OpenAPIHono<AuthEnv>({ defaultHook: validationHook });
+
+publicBranding.use(withRequestId);
+
+publicBranding.openapi(getBrandingRoute, async (c) => runHandler(c, "get public branding", async () => {
+  const req = c.req.raw;
+
+  // Try to resolve the org from the session. This is best-effort — if auth
+  // fails or there's no session, we return null branding.
+  let orgId: string | undefined;
+  try {
+    const authResult = await authenticateRequest(req);
+    if (authResult.authenticated) {
+      orgId = authResult.user?.activeOrganizationId ?? undefined;
+    }
+  } catch (err) {
+    // intentionally ignored: auth failure is expected for unauthenticated visitors
+    log.debug({ err: err instanceof Error ? err.message : String(err) }, "Public branding: auth resolution failed, returning null branding");
+  }
+
+  if (!orgId) {
+    return c.json({ branding: null }, 200);
+  }
+
+  const branding = await getWorkspaceBrandingPublic(orgId);
+  if (!branding) {
+    return c.json({ branding: null }, 200);
+  }
+
+  // Return only public-safe fields (no internal IDs or timestamps)
+  return c.json({
+    branding: {
+      logoUrl: branding.logoUrl,
+      logoText: branding.logoText,
+      primaryColor: branding.primaryColor,
+      faviconUrl: branding.faviconUrl,
+      hideAtlasBranding: branding.hideAtlasBranding,
+    },
+  }, 200);
+}));
+
+export { publicBranding };