@ampless/admin 0.2.0-alpha.0

package/dist/index.d.ts

@@ -0,0 +1,75 @@
+import { Config } from 'ampless';
+import { AmplessOutputs, EffectiveSiteSettings, EffectiveThemeConfig, Ampless } from '@ampless/runtime';
+import { L as Locale, D as Dictionary } from './i18n-ByHM_Bho.js';
+export { A as AdminLocaleStrings, g as getDictionary, r as resolveLocale, t as translate } from './i18n-ByHM_Bho.js';
+import * as _aws_amplify_adapter_nextjs from '@aws-amplify/adapter-nextjs';
+
+/**
+ * Build a Next.js Amplify server runner from outputs. Returns the
+ * `runWithAmplifyServerContext` helper used by API routes / server
+ * components that need cookie-aware Amplify calls (auth, signed-URL
+ * media proxy).
+ */
+declare function createAmplifyServer(outputs: AmplessOutputs): _aws_amplify_adapter_nextjs.NextServer.CreateServerRunnerOutput;
+type AmplifyServer = ReturnType<typeof createAmplifyServer>;
+
+interface ServerSession {
+    userId: string;
+    email: string;
+    groups: string[];
+}
+
+interface CreateAdminOpts {
+    outputs: AmplessOutputs;
+    cmsConfig: Config;
+    /**
+     * Optional pre-built ampless runtime instance for cross-package
+     * sharing. When omitted, admin doesn't build one — server pages
+     * (sites list / site edit / theme edit) still need
+     * `loadSiteSettings` / `loadThemeConfig`, so passing an `ampless`
+     * here lets admin reuse the same runtime your public pages already
+     * use. If not provided, the admin's server pages won't be able to
+     * load site settings.
+     */
+    ampless?: Ampless;
+    /**
+     * Locale for admin UI strings. Pass a string code ('en', 'ja') for a
+     * built-in dictionary, or an object literal to override specific
+     * strings. Defaults to English.
+     */
+    locale?: string | Record<string, unknown>;
+}
+interface Admin {
+    t(key: string, vars?: Record<string, string | number>): string;
+    readonly locale: Locale;
+    readonly dict: Dictionary;
+    getServerSession(): Promise<ServerSession | null>;
+    isAdmin(session: ServerSession | null): boolean;
+    isEditor(session: ServerSession | null): boolean;
+    readonly amplifyServer: AmplifyServer;
+    currentAdminSiteId(): Promise<string>;
+    adminSiteOptions(): Array<{
+        id: string;
+        name: string;
+    }>;
+    loadSiteSettings(siteId?: string): Promise<EffectiveSiteSettings>;
+    loadThemeConfig(siteId?: string): Promise<EffectiveThemeConfig>;
+    publicMediaUrl(input: string): string;
+    readonly outputs: AmplessOutputs;
+    readonly cmsConfig: Config;
+    readonly ampless: Ampless | null;
+}
+/**
+ * Wire up the admin UI from user-supplied config blobs. Returns an
+ * `Admin` instance containing everything page / API factories need —
+ * the same instance is shared by `<AdminLayout>`, `<PostForm>`,
+ * `<SiteSelector>`, `/api/media`, etc.
+ *
+ * If `opts.ampless` is omitted, server-side pages that depend on
+ * `loadSiteSettings` / `loadThemeConfig` (the sites edit and theme
+ * pages) will throw. Pass the same runtime instance you already use on
+ * the public side for shared caching.
+ */
+declare function createAdmin(opts: CreateAdminOpts): Admin;
+
+export { type Admin, type CreateAdminOpts, Dictionary, Locale, type ServerSession, createAdmin };

package/dist/index.js

@@ -0,0 +1,115 @@
+import {
+  ADMIN_SITE_COOKIE,
+  createMedia,
+  getDictionary,
+  resolveLocale,
+  translate
+} from "./chunk-TJR3ALRJ.js";
+
+// src/lib/admin-site.ts
+import { cookies } from "next/headers";
+import { DEFAULT_SITE_ID, isMultiSite, siteFor } from "ampless";
+function createAdminSite(cmsConfig) {
+  async function currentAdminSiteId() {
+    if (!isMultiSite(cmsConfig)) return DEFAULT_SITE_ID;
+    const sites = cmsConfig.sites ?? {};
+    const c = await cookies();
+    const v = c.get(ADMIN_SITE_COOKIE)?.value;
+    if (v && sites[v]) return v;
+    const first = Object.keys(sites)[0];
+    return first ?? DEFAULT_SITE_ID;
+  }
+  function adminSiteOptions() {
+    if (!isMultiSite(cmsConfig)) return [];
+    return Object.entries(cmsConfig.sites ?? {}).map(([id]) => ({
+      id,
+      name: siteFor(id, cmsConfig).name
+    }));
+  }
+  return { currentAdminSiteId, adminSiteOptions };
+}
+
+// src/lib/amplify-server.ts
+import { createServerRunner } from "@aws-amplify/adapter-nextjs";
+function createAmplifyServer(outputs) {
+  return createServerRunner({
+    config: outputs
+  });
+}
+
+// src/lib/auth-server.ts
+import { cookies as cookies2 } from "next/headers";
+import { fetchAuthSession, getCurrentUser } from "aws-amplify/auth/server";
+function createAuthServer(server) {
+  const { runWithAmplifyServerContext } = server;
+  async function getServerSession() {
+    try {
+      const session = await runWithAmplifyServerContext({
+        nextServerContext: { cookies: cookies2 },
+        operation: async (ctx) => {
+          const authSession = await fetchAuthSession(ctx);
+          const user = await getCurrentUser(ctx);
+          const payload = authSession.tokens?.accessToken.payload;
+          const groups = payload?.["cognito:groups"] ?? [];
+          return {
+            userId: user.userId,
+            email: user.signInDetails?.loginId ?? "",
+            groups
+          };
+        }
+      });
+      return session;
+    } catch {
+      return null;
+    }
+  }
+  function isAdmin(session) {
+    return !!session && session.groups.includes("ampless-admin");
+  }
+  function isEditor(session) {
+    return !!session && (session.groups.includes("ampless-admin") || session.groups.includes("ampless-editor"));
+  }
+  return { getServerSession, isAdmin, isEditor };
+}
+
+// src/index.ts
+function createAdmin(opts) {
+  const { outputs, cmsConfig, ampless: amplessIn, locale: localeOpt } = opts;
+  const { locale, dict } = resolveLocale(localeOpt);
+  const adminSite = createAdminSite(cmsConfig);
+  const amplifyServer = createAmplifyServer(outputs);
+  const auth = createAuthServer(amplifyServer);
+  const media = createMedia(outputs, cmsConfig);
+  const ampless = amplessIn ?? null;
+  function requireAmpless() {
+    if (!ampless) {
+      throw new Error(
+        "[@ampless/admin] createAdmin was called without an `ampless` runtime instance, but a method that needs one (loadSiteSettings / loadThemeConfig) was invoked. Pass `ampless` in the `createAdmin` options so admin can reuse your public-side runtime."
+      );
+    }
+    return ampless;
+  }
+  return {
+    t: (key, vars) => translate(dict, key, vars),
+    locale,
+    dict,
+    getServerSession: auth.getServerSession,
+    isAdmin: auth.isAdmin,
+    isEditor: auth.isEditor,
+    amplifyServer,
+    currentAdminSiteId: adminSite.currentAdminSiteId,
+    adminSiteOptions: adminSite.adminSiteOptions,
+    loadSiteSettings: (siteId) => requireAmpless().loadSiteSettings(siteId),
+    loadThemeConfig: (siteId) => requireAmpless().loadThemeConfig(siteId),
+    publicMediaUrl: media.publicMediaUrl,
+    outputs,
+    cmsConfig,
+    ampless
+  };
+}
+export {
+  createAdmin,
+  getDictionary,
+  resolveLocale,
+  translate
+};

package/dist/pages/index.d.ts

@@ -0,0 +1,90 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { Admin } from '../index.js';
+import { ThemeManifest } from 'ampless';
+import '@ampless/runtime';
+import '../i18n-ByHM_Bho.js';
+import '@aws-amplify/adapter-nextjs';
+
+/**
+ * Build the admin layout component. Wraps every admin route with:
+ *
+ * - An auth gate (`redirect('/login')` if the visitor isn't in the
+ *   `ampless-admin` or `ampless-editor` Cognito group).
+ * - The admin sidebar (with optional multi-site selector).
+ * - An i18n provider hydrated from the resolved locale dict.
+ * - A client-side `AdminProviders` shell that configures the Amplify
+ *   SDK and installs the admin's posts / kv providers once on mount.
+ */
+declare function createAdminLayout(admin: Admin): ({ children }: {
+    children: React.ReactNode;
+}) => Promise<react_jsx_runtime.JSX.Element>;
+
+declare function AdminDashboard(): react_jsx_runtime.JSX.Element;
+/**
+ * Admin home / dashboard. Lists post counts. Marked client-side because
+ * it reads from the AppSync client directly (no server-rendered query
+ * yet — listed posts come from Amplify SDK at mount time).
+ */
+declare function createAdminDashboardPage(_admin: unknown): typeof AdminDashboard;
+
+declare function PostsList(): react_jsx_runtime.JSX.Element;
+declare function createPostsListPage(_admin: unknown): typeof PostsList;
+
+declare function NewPostPage(): react_jsx_runtime.JSX.Element;
+declare function createNewPostPage(_admin: unknown): typeof NewPostPage;
+
+declare function EditPostPage({ params }: {
+    params: Promise<{
+        postId: string;
+    }>;
+}): react_jsx_runtime.JSX.Element;
+declare function createEditPostPage(_admin: unknown): typeof EditPostPage;
+
+declare function MediaPage(): react_jsx_runtime.JSX.Element;
+declare function createMediaPage(_admin: unknown): typeof MediaPage;
+
+/**
+ * Sites overview. In single-site mode there's exactly one row
+ * (`default`); in multi-site mode each declared site shows up. Adding
+ * / removing sites is still done in cms.config.ts (the domains[] field
+ * is wired to DNS / SSL outside ampless's reach).
+ */
+declare function createSitesListPage(admin: Admin): () => Promise<react_jsx_runtime.JSX.Element>;
+
+interface Props$1 {
+    params: Promise<{
+        siteId: string;
+    }>;
+}
+/**
+ * Server-rendered: pre-fills the form with the merged settings (so the
+ * editor sees what's currently effective). The form itself writes
+ * directly to KvStore via the AppSync client; no Server Action needed.
+ */
+declare function createSiteEditPage(admin: Admin): ({ params }: Props$1) => Promise<react_jsx_runtime.JSX.Element>;
+
+interface Props {
+    params: Promise<{
+        siteId: string;
+    }>;
+}
+interface ThemeListEntry {
+    name: string;
+    manifest: ThemeManifest;
+}
+/**
+ * Theme admin: pick which installed theme is active for this site, plus
+ * edit the active theme's customizable manifest fields. Reads through
+ * the S3 site-settings cache (same path the public site uses) so the
+ * admin sees the same effective state visitors see.
+ *
+ * The full `themeList` (one entry per installed theme manifest) is
+ * passed in because the registry lives in the user's project — admin
+ * stays agnostic of which themes a project happens to install.
+ */
+declare function createSiteThemePage(admin: Admin, themeList: ReadonlyArray<ThemeListEntry>): ({ params }: Props) => Promise<react_jsx_runtime.JSX.Element>;
+
+declare function LoginPage(): react_jsx_runtime.JSX.Element;
+declare function createLoginPage(_admin: unknown): typeof LoginPage;
+
+export { createAdminDashboardPage, createAdminLayout, createEditPostPage, createLoginPage, createMediaPage, createNewPostPage, createPostsListPage, createSiteEditPage, createSiteThemePage, createSitesListPage };