@btst/stack 5.1.0 → 5.2.0

package/dist/packages/stack/src/plugins/school/api/plugin.cjs

@@ -0,0 +1,214 @@
+'use strict';
+
+const api = require('@btst/stack/plugins/api');
+const z = require('zod');
+const db = require('../db.cjs');
+const schemas = require('../schemas.cjs');
+const getters = require('./getters.cjs');
+const operations = require('./operations.cjs');
+const mutations = require('./mutations.cjs');
+const queryKeyDefs = require('./query-key-defs.cjs');
+
+function schoolBackendPlugin(options = {}) {
+  z.z.number().min(0).max(100).parse(options.quizPassMark ?? 70);
+  return api.defineBackendPlugin({
+    id: "school",
+    dbPlugin: db.schoolSchema,
+    operations: (adapter, context) => {
+      if (!Object.values(context?.plugins ?? {}).some(
+        (plugin) => plugin.id === "cms"
+      ))
+        throw new Error(
+          "School requires cmsBackendPlugin with SCHOOL_COURSE_CONTENT_TYPE registered"
+        );
+      return operations.createSchoolOperations(adapter, options);
+    },
+    raw: (adapter) => ({
+      prefetchForRoute: (async (key, queryClient, params) => {
+        await mutations.ensureSchoolCourseType(adapter);
+        if (key === "catalog") {
+          queryClient.setQueryData(
+            queryKeyDefs.SCHOOL_QUERY_KEYS.list(params),
+            await getters.listCourses(adapter, params)
+          );
+          return;
+        }
+        const course = await getters.getCourseBySlug(adapter, params?.slug ?? "");
+        if (!course)
+          throw new api.OperationHttpError(
+            404,
+            "Course not found",
+            "SCHOOL_COURSE_NOT_FOUND"
+          );
+        queryClient.setQueryData(
+          queryKeyDefs.SCHOOL_QUERY_KEYS.detail(course.slug),
+          await getters.getCourseDetail(adapter, course)
+        );
+      })
+    }),
+    routes: (_adapter, _context, ops) => ({
+      listCourses: api.createEndpoint(
+        "/school/courses",
+        { method: "GET", query: schemas.courseFiltersSchema, requireRequest: true },
+        ops.listCourses.route((ctx) => ctx.query)
+      ),
+      getCourse: api.createEndpoint(
+        "/school/catalog/:slug",
+        { method: "GET", requireRequest: true },
+        ops.getCourse.route((ctx) => ({ slug: ctx.params.slug }))
+      ),
+      getInstructorCourse: api.createEndpoint(
+        "/school/courses/:id",
+        { method: "GET", requireRequest: true },
+        ops.getInstructorCourse.route((ctx) => ({ id: ctx.params.id }))
+      ),
+      listInstructorCourses: api.createEndpoint(
+        "/school/instructor",
+        { method: "GET", requireRequest: true },
+        ops.listInstructorCourses.route(() => ({}))
+      ),
+      createCourse: api.createEndpoint(
+        "/school/courses",
+        { method: "POST", body: schemas.courseSchema, requireRequest: true },
+        ops.createCourse.route((ctx) => ctx.body)
+      ),
+      updateCourse: api.createEndpoint(
+        "/school/courses/:id",
+        { method: "PATCH", body: schemas.courseUpdateSchema, requireRequest: true },
+        ops.updateCourse.route((ctx) => ({
+          id: ctx.params.id,
+          data: ctx.body
+        }))
+      ),
+      deleteCourse: api.createEndpoint(
+        "/school/courses/:id",
+        { method: "DELETE", requireRequest: true },
+        ops.deleteCourse.route((ctx) => ({ id: ctx.params.id }))
+      ),
+      createSection: api.createEndpoint(
+        "/school/courses/:id/sections",
+        { method: "POST", body: schemas.sectionSchema, requireRequest: true },
+        ops.createSection.route((ctx) => ({
+          courseId: ctx.params.id,
+          data: ctx.body
+        }))
+      ),
+      updateSection: api.createEndpoint(
+        "/school/sections/:id",
+        { method: "PATCH", body: schemas.sectionUpdateSchema, requireRequest: true },
+        ops.updateSection.route((ctx) => ({
+          id: ctx.params.id,
+          data: ctx.body
+        }))
+      ),
+      deleteSection: api.createEndpoint(
+        "/school/sections/:id",
+        { method: "DELETE", requireRequest: true },
+        ops.deleteSection.route((ctx) => ({ id: ctx.params.id }))
+      ),
+      createLesson: api.createEndpoint(
+        "/school/courses/:id/lessons",
+        { method: "POST", body: schemas.lessonSchema, requireRequest: true },
+        ops.createLesson.route((ctx) => ({
+          courseId: ctx.params.id,
+          data: ctx.body
+        }))
+      ),
+      updateLesson: api.createEndpoint(
+        "/school/lessons/:id",
+        { method: "PATCH", body: schemas.lessonUpdateSchema, requireRequest: true },
+        ops.updateLesson.route((ctx) => ({
+          id: ctx.params.id,
+          data: ctx.body
+        }))
+      ),
+      getEditableLesson: api.createEndpoint(
+        "/school/lessons/:id/edit",
+        { method: "GET", requireRequest: true },
+        ops.getEditableLesson.route((ctx) => ({ id: ctx.params.id }))
+      ),
+      deleteLesson: api.createEndpoint(
+        "/school/lessons/:id",
+        { method: "DELETE", requireRequest: true },
+        ops.deleteLesson.route((ctx) => ({ id: ctx.params.id }))
+      ),
+      reorderLessons: api.createEndpoint(
+        "/school/courses/:id/reorder",
+        {
+          method: "POST",
+          body: z.z.object({ lessonIds: z.z.array(z.z.string()) }),
+          requireRequest: true
+        },
+        ops.reorderLessons.route((ctx) => ({ id: ctx.params.id, ...ctx.body }))
+      ),
+      enroll: api.createEndpoint(
+        "/school/courses/:id/enroll",
+        { method: "POST", requireRequest: true },
+        ops.enroll.route((ctx) => ({ id: ctx.params.id }))
+      ),
+      cancelEnrollment: api.createEndpoint(
+        "/school/courses/:id/cancel",
+        { method: "POST", requireRequest: true },
+        ops.cancelEnrollment.route((ctx) => ({ id: ctx.params.id }))
+      ),
+      retryCertificate: api.createEndpoint(
+        "/school/courses/:id/certificate",
+        { method: "POST", requireRequest: true },
+        ops.retryCertificate.route((ctx) => ({ id: ctx.params.id }))
+      ),
+      getMyCourses: api.createEndpoint(
+        "/school/me",
+        { method: "GET", requireRequest: true },
+        ops.getMyCourses.route(() => ({}))
+      ),
+      getLesson: api.createEndpoint(
+        "/school/lessons/:id",
+        { method: "GET", requireRequest: true },
+        ops.getLesson.route((ctx) => ({ id: ctx.params.id }))
+      ),
+      saveProgress: api.createEndpoint(
+        "/school/lessons/:id/progress",
+        { method: "POST", body: schemas.progressSchema, requireRequest: true },
+        ops.saveProgress.route((ctx) => ({
+          id: ctx.params.id,
+          data: ctx.body
+        }))
+      ),
+      submitQuiz: api.createEndpoint(
+        "/school/lessons/:id/quiz",
+        { method: "POST", body: schemas.quizSubmissionSchema, requireRequest: true },
+        ops.submitQuiz.route((ctx) => ({ id: ctx.params.id, data: ctx.body }))
+      ),
+      listQuizAttempts: api.createEndpoint(
+        "/school/lessons/:id/attempts",
+        { method: "GET", requireRequest: true },
+        ops.listQuizAttempts.route((ctx) => ({ id: ctx.params.id }))
+      ),
+      listStudents: api.createEndpoint(
+        "/school/courses/:id/students",
+        { method: "GET", requireRequest: true },
+        ops.listStudents.route((ctx) => ({ id: ctx.params.id }))
+      ),
+      verifyCertificate: api.createEndpoint(
+        "/school/certificates/:id",
+        { method: "GET", requireRequest: true },
+        ops.verifyCertificate.route((ctx) => ({ id: ctx.params.id }))
+      ),
+      createReview: api.createEndpoint(
+        "/school/courses/:id/reviews",
+        { method: "POST", body: schemas.reviewSchema, requireRequest: true },
+        ops.createReview.route((ctx) => ({
+          id: ctx.params.id,
+          data: ctx.body
+        }))
+      ),
+      listReviews: api.createEndpoint(
+        "/school/courses/:id/reviews",
+        { method: "GET", requireRequest: true },
+        ops.listReviews.route((ctx) => ({ id: ctx.params.id }))
+      )
+    })
+  });
+}
+
+exports.schoolBackendPlugin = schoolBackendPlugin;

package/dist/packages/stack/src/plugins/school/api/plugin.mjs

@@ -0,0 +1,212 @@
+import { defineBackendPlugin, createEndpoint, OperationHttpError } from '@btst/stack/plugins/api';
+import { z } from 'zod';
+import { schoolSchema } from '../db.mjs';
+import { reviewSchema, quizSubmissionSchema, progressSchema, lessonUpdateSchema, lessonSchema, sectionUpdateSchema, sectionSchema, courseUpdateSchema, courseSchema, courseFiltersSchema } from '../schemas.mjs';
+import { listCourses, getCourseBySlug, getCourseDetail } from './getters.mjs';
+import { createSchoolOperations } from './operations.mjs';
+import { ensureSchoolCourseType } from './mutations.mjs';
+import { SCHOOL_QUERY_KEYS } from './query-key-defs.mjs';
+
+function schoolBackendPlugin(options = {}) {
+  z.number().min(0).max(100).parse(options.quizPassMark ?? 70);
+  return defineBackendPlugin({
+    id: "school",
+    dbPlugin: schoolSchema,
+    operations: (adapter, context) => {
+      if (!Object.values(context?.plugins ?? {}).some(
+        (plugin) => plugin.id === "cms"
+      ))
+        throw new Error(
+          "School requires cmsBackendPlugin with SCHOOL_COURSE_CONTENT_TYPE registered"
+        );
+      return createSchoolOperations(adapter, options);
+    },
+    raw: (adapter) => ({
+      prefetchForRoute: (async (key, queryClient, params) => {
+        await ensureSchoolCourseType(adapter);
+        if (key === "catalog") {
+          queryClient.setQueryData(
+            SCHOOL_QUERY_KEYS.list(params),
+            await listCourses(adapter, params)
+          );
+          return;
+        }
+        const course = await getCourseBySlug(adapter, params?.slug ?? "");
+        if (!course)
+          throw new OperationHttpError(
+            404,
+            "Course not found",
+            "SCHOOL_COURSE_NOT_FOUND"
+          );
+        queryClient.setQueryData(
+          SCHOOL_QUERY_KEYS.detail(course.slug),
+          await getCourseDetail(adapter, course)
+        );
+      })
+    }),
+    routes: (_adapter, _context, ops) => ({
+      listCourses: createEndpoint(
+        "/school/courses",
+        { method: "GET", query: courseFiltersSchema, requireRequest: true },
+        ops.listCourses.route((ctx) => ctx.query)
+      ),
+      getCourse: createEndpoint(
+        "/school/catalog/:slug",
+        { method: "GET", requireRequest: true },
+        ops.getCourse.route((ctx) => ({ slug: ctx.params.slug }))
+      ),
+      getInstructorCourse: createEndpoint(
+        "/school/courses/:id",
+        { method: "GET", requireRequest: true },
+        ops.getInstructorCourse.route((ctx) => ({ id: ctx.params.id }))
+      ),
+      listInstructorCourses: createEndpoint(
+        "/school/instructor",
+        { method: "GET", requireRequest: true },
+        ops.listInstructorCourses.route(() => ({}))
+      ),
+      createCourse: createEndpoint(
+        "/school/courses",
+        { method: "POST", body: courseSchema, requireRequest: true },
+        ops.createCourse.route((ctx) => ctx.body)
+      ),
+      updateCourse: createEndpoint(
+        "/school/courses/:id",
+        { method: "PATCH", body: courseUpdateSchema, requireRequest: true },
+        ops.updateCourse.route((ctx) => ({
+          id: ctx.params.id,
+          data: ctx.body
+        }))
+      ),
+      deleteCourse: createEndpoint(
+        "/school/courses/:id",
+        { method: "DELETE", requireRequest: true },
+        ops.deleteCourse.route((ctx) => ({ id: ctx.params.id }))
+      ),
+      createSection: createEndpoint(
+        "/school/courses/:id/sections",
+        { method: "POST", body: sectionSchema, requireRequest: true },
+        ops.createSection.route((ctx) => ({
+          courseId: ctx.params.id,
+          data: ctx.body
+        }))
+      ),
+      updateSection: createEndpoint(
+        "/school/sections/:id",
+        { method: "PATCH", body: sectionUpdateSchema, requireRequest: true },
+        ops.updateSection.route((ctx) => ({
+          id: ctx.params.id,
+          data: ctx.body
+        }))
+      ),
+      deleteSection: createEndpoint(
+        "/school/sections/:id",
+        { method: "DELETE", requireRequest: true },
+        ops.deleteSection.route((ctx) => ({ id: ctx.params.id }))
+      ),
+      createLesson: createEndpoint(
+        "/school/courses/:id/lessons",
+        { method: "POST", body: lessonSchema, requireRequest: true },
+        ops.createLesson.route((ctx) => ({
+          courseId: ctx.params.id,
+          data: ctx.body
+        }))
+      ),
+      updateLesson: createEndpoint(
+        "/school/lessons/:id",
+        { method: "PATCH", body: lessonUpdateSchema, requireRequest: true },
+        ops.updateLesson.route((ctx) => ({
+          id: ctx.params.id,
+          data: ctx.body
+        }))
+      ),
+      getEditableLesson: createEndpoint(
+        "/school/lessons/:id/edit",
+        { method: "GET", requireRequest: true },
+        ops.getEditableLesson.route((ctx) => ({ id: ctx.params.id }))
+      ),
+      deleteLesson: createEndpoint(
+        "/school/lessons/:id",
+        { method: "DELETE", requireRequest: true },
+        ops.deleteLesson.route((ctx) => ({ id: ctx.params.id }))
+      ),
+      reorderLessons: createEndpoint(
+        "/school/courses/:id/reorder",
+        {
+          method: "POST",
+          body: z.object({ lessonIds: z.array(z.string()) }),
+          requireRequest: true
+        },
+        ops.reorderLessons.route((ctx) => ({ id: ctx.params.id, ...ctx.body }))
+      ),
+      enroll: createEndpoint(
+        "/school/courses/:id/enroll",
+        { method: "POST", requireRequest: true },
+        ops.enroll.route((ctx) => ({ id: ctx.params.id }))
+      ),
+      cancelEnrollment: createEndpoint(
+        "/school/courses/:id/cancel",
+        { method: "POST", requireRequest: true },
+        ops.cancelEnrollment.route((ctx) => ({ id: ctx.params.id }))
+      ),
+      retryCertificate: createEndpoint(
+        "/school/courses/:id/certificate",
+        { method: "POST", requireRequest: true },
+        ops.retryCertificate.route((ctx) => ({ id: ctx.params.id }))
+      ),
+      getMyCourses: createEndpoint(
+        "/school/me",
+        { method: "GET", requireRequest: true },
+        ops.getMyCourses.route(() => ({}))
+      ),
+      getLesson: createEndpoint(
+        "/school/lessons/:id",
+        { method: "GET", requireRequest: true },
+        ops.getLesson.route((ctx) => ({ id: ctx.params.id }))
+      ),
+      saveProgress: createEndpoint(
+        "/school/lessons/:id/progress",
+        { method: "POST", body: progressSchema, requireRequest: true },
+        ops.saveProgress.route((ctx) => ({
+          id: ctx.params.id,
+          data: ctx.body
+        }))
+      ),
+      submitQuiz: createEndpoint(
+        "/school/lessons/:id/quiz",
+        { method: "POST", body: quizSubmissionSchema, requireRequest: true },
+        ops.submitQuiz.route((ctx) => ({ id: ctx.params.id, data: ctx.body }))
+      ),
+      listQuizAttempts: createEndpoint(
+        "/school/lessons/:id/attempts",
+        { method: "GET", requireRequest: true },
+        ops.listQuizAttempts.route((ctx) => ({ id: ctx.params.id }))
+      ),
+      listStudents: createEndpoint(
+        "/school/courses/:id/students",
+        { method: "GET", requireRequest: true },
+        ops.listStudents.route((ctx) => ({ id: ctx.params.id }))
+      ),
+      verifyCertificate: createEndpoint(
+        "/school/certificates/:id",
+        { method: "GET", requireRequest: true },
+        ops.verifyCertificate.route((ctx) => ({ id: ctx.params.id }))
+      ),
+      createReview: createEndpoint(
+        "/school/courses/:id/reviews",
+        { method: "POST", body: reviewSchema, requireRequest: true },
+        ops.createReview.route((ctx) => ({
+          id: ctx.params.id,
+          data: ctx.body
+        }))
+      ),
+      listReviews: createEndpoint(
+        "/school/courses/:id/reviews",
+        { method: "GET", requireRequest: true },
+        ops.listReviews.route((ctx) => ({ id: ctx.params.id }))
+      )
+    })
+  });
+}
+
+export { schoolBackendPlugin };

package/dist/packages/stack/src/plugins/school/api/query-key-defs.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+const schemas = require('../schemas.cjs');
+
+const SCHOOL_QUERY_KEYS = {
+  list: (filters = {}) => ["schoolCourses", "list", schemas.courseFiltersSchema.parse(filters)],
+  detail: (slug) => ["schoolCourses", "detail", slug]
+};
+
+exports.SCHOOL_QUERY_KEYS = SCHOOL_QUERY_KEYS;

package/dist/packages/stack/src/plugins/school/api/query-key-defs.mjs

@@ -0,0 +1,8 @@
+import { courseFiltersSchema } from '../schemas.mjs';
+
+const SCHOOL_QUERY_KEYS = {
+  list: (filters = {}) => ["schoolCourses", "list", courseFiltersSchema.parse(filters)],
+  detail: (slug) => ["schoolCourses", "detail", slug]
+};
+
+export { SCHOOL_QUERY_KEYS };

package/dist/packages/stack/src/plugins/school/api/records.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+async function findAllSchoolRecords(adapter, options) {
+  const records = [];
+  for (let offset = 0; ; ) {
+    const page = await adapter.findMany({
+      ...options,
+      limit: 100,
+      offset,
+      sortBy: { field: "id", direction: "asc" }
+    });
+    if (page.length === 0) return records;
+    records.push(...page);
+    offset += page.length;
+  }
+}
+
+exports.findAllSchoolRecords = findAllSchoolRecords;

package/dist/packages/stack/src/plugins/school/api/records.mjs

@@ -0,0 +1,16 @@
+async function findAllSchoolRecords(adapter, options) {
+  const records = [];
+  for (let offset = 0; ; ) {
+    const page = await adapter.findMany({
+      ...options,
+      limit: 100,
+      offset,
+      sortBy: { field: "id", direction: "asc" }
+    });
+    if (page.length === 0) return records;
+    records.push(...page);
+    offset += page.length;
+  }
+}
+
+export { findAllSchoolRecords };

package/dist/packages/stack/src/plugins/school/api/serializers.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+function serializeSchoolRecord(record) {
+  return JSON.parse(JSON.stringify(record));
+}
+
+exports.serializeSchoolRecord = serializeSchoolRecord;

package/dist/packages/stack/src/plugins/school/api/serializers.mjs

@@ -0,0 +1,5 @@
+function serializeSchoolRecord(record) {
+  return JSON.parse(JSON.stringify(record));
+}
+
+export { serializeSchoolRecord };

package/dist/packages/stack/src/plugins/school/client/components/pages/certificate-page.cjs

@@ -0,0 +1,31 @@
+"use client";
+'use strict';
+
+const jsxRuntime = require('react/jsx-runtime');
+const React = require('react');
+const components = require('@btst/stack/client/components');
+const routeState = require('./route-state.cjs');
+
+const Page = React.lazy(
+  () => import('./certificate-page.internal.cjs').then((m) => ({
+    default: m.CertificatePage
+  }))
+);
+function CertificatePageComponent({
+  certificateId
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    components.ComposedRoute,
+    {
+      path: `/learn/certificates/${certificateId}`,
+      PageComponent: Page,
+      LoadingComponent: routeState.SchoolLoading,
+      ErrorComponent: routeState.SchoolError,
+      NotFoundComponent: routeState.SchoolNotFound,
+      props: { certificateId },
+      onError: (error) => console.error("[btst/school]", error)
+    }
+  );
+}
+
+exports.CertificatePageComponent = CertificatePageComponent;

package/dist/packages/stack/src/plugins/school/client/components/pages/certificate-page.internal.cjs

@@ -0,0 +1,31 @@
+"use client";
+'use strict';
+
+const jsxRuntime = require('react/jsx-runtime');
+const LucideIcons = require('lucide-react');
+const plugins_school_client_hooks_index = require('../../../../../../../../plugins/school/client/hooks/index.cjs');
+const schoolShared = require('./school-shared.cjs');
+
+function CertificatePage({ certificateId }) {
+  const { data } = plugins_school_client_hooks_index.useCertificate(certificateId);
+  return /* @__PURE__ */ jsxRuntime.jsx(schoolShared.SchoolShell, { title: "Certificate verification", children: /* @__PURE__ */ jsxRuntime.jsxs("article", { className: "school-certificate", children: [
+    /* @__PURE__ */ jsxRuntime.jsx(LucideIcons.Award, { size: 40, "aria-hidden": "true" }),
+    /* @__PURE__ */ jsxRuntime.jsx("p", { children: "Verified completion" }),
+    /* @__PURE__ */ jsxRuntime.jsx("h2", { children: data.courseTitle }),
+    /* @__PURE__ */ jsxRuntime.jsx("p", { children: "All lessons in this course have been completed." }),
+    /* @__PURE__ */ jsxRuntime.jsxs("dl", { children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+        /* @__PURE__ */ jsxRuntime.jsx("dt", { children: "Completed" }),
+        /* @__PURE__ */ jsxRuntime.jsx("dd", { children: new Date(data.completedAt).toLocaleDateString("en-US", {
+          timeZone: "UTC"
+        }) })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+        /* @__PURE__ */ jsxRuntime.jsx("dt", { children: "Certificate ID" }),
+        /* @__PURE__ */ jsxRuntime.jsx("dd", { children: data.certificateId })
+      ] })
+    ] })
+  ] }) });
+}
+
+exports.CertificatePage = CertificatePage;

package/dist/packages/stack/src/plugins/school/client/components/pages/certificate-page.internal.mjs

@@ -0,0 +1,29 @@
+"use client";
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { Award } from 'lucide-react';
+import { useCertificate } from '../../../../../../../../plugins/school/client/hooks/index.mjs';
+import { SchoolShell } from './school-shared.mjs';
+
+function CertificatePage({ certificateId }) {
+  const { data } = useCertificate(certificateId);
+  return /* @__PURE__ */ jsx(SchoolShell, { title: "Certificate verification", children: /* @__PURE__ */ jsxs("article", { className: "school-certificate", children: [
+    /* @__PURE__ */ jsx(Award, { size: 40, "aria-hidden": "true" }),
+    /* @__PURE__ */ jsx("p", { children: "Verified completion" }),
+    /* @__PURE__ */ jsx("h2", { children: data.courseTitle }),
+    /* @__PURE__ */ jsx("p", { children: "All lessons in this course have been completed." }),
+    /* @__PURE__ */ jsxs("dl", { children: [
+      /* @__PURE__ */ jsxs("div", { children: [
+        /* @__PURE__ */ jsx("dt", { children: "Completed" }),
+        /* @__PURE__ */ jsx("dd", { children: new Date(data.completedAt).toLocaleDateString("en-US", {
+          timeZone: "UTC"
+        }) })
+      ] }),
+      /* @__PURE__ */ jsxs("div", { children: [
+        /* @__PURE__ */ jsx("dt", { children: "Certificate ID" }),
+        /* @__PURE__ */ jsx("dd", { children: data.certificateId })
+      ] })
+    ] })
+  ] }) });
+}
+
+export { CertificatePage };

package/dist/packages/stack/src/plugins/school/client/components/pages/certificate-page.mjs

@@ -0,0 +1,29 @@
+"use client";
+import { jsx } from 'react/jsx-runtime';
+import { lazy } from 'react';
+import { ComposedRoute } from '@btst/stack/client/components';
+import { SchoolNotFound, SchoolError, SchoolLoading } from './route-state.mjs';
+
+const Page = lazy(
+  () => import('./certificate-page.internal.mjs').then((m) => ({
+    default: m.CertificatePage
+  }))
+);
+function CertificatePageComponent({
+  certificateId
+}) {
+  return /* @__PURE__ */ jsx(
+    ComposedRoute,
+    {
+      path: `/learn/certificates/${certificateId}`,
+      PageComponent: Page,
+      LoadingComponent: SchoolLoading,
+      ErrorComponent: SchoolError,
+      NotFoundComponent: SchoolNotFound,
+      props: { certificateId },
+      onError: (error) => console.error("[btst/school]", error)
+    }
+  );
+}
+
+export { CertificatePageComponent };

package/dist/packages/stack/src/plugins/school/client/components/pages/course-detail-page.cjs

@@ -0,0 +1,29 @@
+"use client";
+'use strict';
+
+const jsxRuntime = require('react/jsx-runtime');
+const React = require('react');
+const components = require('@btst/stack/client/components');
+const routeState = require('./route-state.cjs');
+
+const Page = React.lazy(
+  () => import('./course-detail-page.internal.cjs').then((m) => ({
+    default: m.CourseDetailPage
+  }))
+);
+function CourseDetailPageComponent({ slug }) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    components.ComposedRoute,
+    {
+      path: `/learn/${slug}`,
+      PageComponent: Page,
+      LoadingComponent: routeState.SchoolLoading,
+      ErrorComponent: routeState.SchoolError,
+      NotFoundComponent: routeState.SchoolNotFound,
+      props: { slug },
+      onError: (error) => console.error("[btst/school]", error)
+    }
+  );
+}
+
+exports.CourseDetailPageComponent = CourseDetailPageComponent;