@btst/stack 5.0.0 → 5.2.0

package/dist/packages/stack/src/plugins/newsletter/client/plugin.mjs

@@ -0,0 +1,142 @@
+import { jsx } from 'react/jsx-runtime';
+import { lazy } from 'react';
+import { defineRoutes, defineRoute } from '@btst/yar';
+import { defineClientPlugin, createApiClient, createSanitizedSSRLoaderError, isConnectionError } from '@btst/stack/plugins/client';
+import { createNewsletterQueryKeys } from '../../../../../../plugins/newsletter/query-keys.mjs';
+import { NEWSLETTER_PLUGIN_ID } from './constants.mjs';
+
+const Subscribers = lazy(
+  () => import('./components/pages.mjs').then((m) => ({
+    default: m.SubscribersPageComponent
+  }))
+);
+const Campaigns = lazy(
+  () => import('./components/pages.mjs').then((m) => ({
+    default: m.CampaignsPageComponent
+  }))
+);
+const Editor = lazy(
+  () => import('./components/pages.mjs').then((m) => ({
+    default: m.EditCampaignPageComponent
+  }))
+);
+const Stats = lazy(
+  () => import('./components/pages.mjs').then((m) => ({
+    default: m.CampaignStatsPageComponent
+  }))
+);
+const newsletterClientPlugin = (config = {}) => defineClientPlugin()({
+  id: NEWSLETTER_PLUGIN_ID,
+  resolve: (runtime) => {
+    const queries = createNewsletterQueryKeys(
+      createApiClient({ ...runtime.api })
+    );
+    const preload = (path, entries = []) => async () => {
+      if (typeof window !== "undefined") return;
+      const context = { path, isSSR: true };
+      let error;
+      try {
+        await config.hooks?.beforeLoad?.(context);
+        await Promise.all(
+          entries.map(
+            (entry) => runtime.queryClient.prefetchQuery({ ...entry, retry: false })
+          )
+        );
+        error = entries.map(
+          (entry) => runtime.queryClient.getQueryState(entry.queryKey)?.error
+        ).find(Boolean);
+        if (!error) await config.hooks?.afterLoad?.(context);
+      } catch (caught) {
+        error = caught;
+        await Promise.all(
+          entries.map(
+            (entry) => runtime.queryClient.prefetchQuery({
+              queryKey: entry.queryKey,
+              queryFn: () => {
+                throw createSanitizedSSRLoaderError();
+              },
+              retry: false,
+              staleTime: 0
+            })
+          )
+        );
+      }
+      if (!error) return;
+      if (isConnectionError(error))
+        console.warn(
+          "[btst/newsletter] API unavailable during SSR prefetch."
+        );
+      try {
+        await config.hooks?.onErrorLoad?.(
+          error instanceof Error ? error : new Error(String(error)),
+          context
+        );
+      } catch {
+      }
+    };
+    const meta = (title) => [
+      { title },
+      { name: "robots", content: "noindex, nofollow" }
+    ];
+    return {
+      routes: () => defineRoutes(
+        {
+          subscribers: defineRoute("/newsletter/subscribers", {
+            page: Subscribers,
+            loader: preload("/newsletter/subscribers", [
+              queries.newsletterSubscribers.list(
+                { limit: 25, offset: 0 },
+                config.identityPartition
+              ),
+              queries.newsletterGrowth.list(config.identityPartition)
+            ]),
+            meta: () => meta("Subscribers")
+          }),
+          campaigns: defineRoute("/newsletter/campaigns", {
+            page: Campaigns,
+            loader: preload("/newsletter/campaigns", [
+              queries.newsletterCampaigns.list(
+                { limit: 25, offset: 0 },
+                config.identityPartition
+              )
+            ]),
+            meta: () => meta("Newsletter campaigns")
+          }),
+          newCampaign: defineRoute("/newsletter/campaigns/new", {
+            page: () => /* @__PURE__ */ jsx(Editor, {}),
+            loader: preload("/newsletter/campaigns/new"),
+            meta: () => meta("New campaign")
+          }),
+          editCampaign: defineRoute("/newsletter/campaigns/:id", {
+            page: ({ params }) => /* @__PURE__ */ jsx(Editor, { id: params.id }),
+            loader: ({ params }) => preload(`/newsletter/campaigns/${params.id}`, [
+              queries.newsletterCampaigns.detail(
+                params.id,
+                config.identityPartition
+              )
+            ])(),
+            meta: () => meta("Edit campaign")
+          }),
+          campaignStats: defineRoute("/newsletter/campaigns/:id/stats", {
+            page: ({ params }) => /* @__PURE__ */ jsx(Stats, { id: params.id }),
+            loader: ({ params }) => preload(`/newsletter/campaigns/${params.id}/stats`, [
+              queries.newsletterCampaigns.detail(
+                params.id,
+                config.identityPartition
+              ),
+              queries.newsletterCampaigns.stats(
+                params.id,
+                config.identityPartition
+              )
+            ])(),
+            meta: () => meta("Campaign results")
+          })
+        },
+        { pages: config.pageComponents }
+      ),
+      sitemap: async () => []
+    };
+  }
+});
+
+export { newsletterClientPlugin };

package/dist/packages/stack/src/plugins/newsletter/db.cjs

@@ -0,0 +1,57 @@
+'use strict';
+
+const db = require('@btst/db');
+
+const newsletterSchema = db.createDbPlugin("newsletter", {
+  subscriber: {
+    modelName: "newsletterSubscriber",
+    fields: {
+      email: { type: "string", required: true, unique: true },
+      name: { type: "string", required: false },
+      status: { type: "string", defaultValue: "subscribed" },
+      transactionOnly: { type: "boolean", defaultValue: false },
+      tags: { type: "string", defaultValue: "[]" },
+      confirmedAt: { type: "date", required: false },
+      createdAt: { type: "date", defaultValue: () => /* @__PURE__ */ new Date() },
+      confirmationToken: { type: "string", required: false },
+      confirmationExpiresAt: { type: "date", required: false },
+      confirmationSentAt: { type: "date", required: false }
+    }
+  },
+  campaign: {
+    modelName: "newsletterCampaign",
+    fields: {
+      subject: { type: "string", required: true },
+      fromName: { type: "string", required: true },
+      fromEmail: { type: "string", required: true },
+      replyTo: { type: "string", required: false },
+      body: { type: "string", required: true },
+      format: { type: "string", defaultValue: "markdown" },
+      tags: { type: "string", defaultValue: "[]" },
+      status: { type: "string", defaultValue: "draft" },
+      scheduledAt: { type: "date", required: false },
+      sentAt: { type: "date", required: false },
+      createdAt: { type: "date", defaultValue: () => /* @__PURE__ */ new Date() },
+      updatedAt: { type: "date", defaultValue: () => /* @__PURE__ */ new Date() }
+    }
+  },
+  send: {
+    modelName: "newsletterSend",
+    fields: {
+      key: { type: "string", required: true, unique: true },
+      campaignId: { type: "string", required: true },
+      subscriberId: { type: "string", required: true },
+      email: { type: "string", required: true },
+      status: { type: "string", defaultValue: "pending" },
+      trackingToken: { type: "string", required: true, unique: true },
+      unsubscribeToken: { type: "string", required: true, unique: true },
+      links: { type: "string", defaultValue: "[]" },
+      messageId: { type: "string", required: false },
+      sentAt: { type: "date", required: false },
+      openedAt: { type: "date", required: false },
+      clickedAt: { type: "date", required: false }
+    }
+  }
+});
+
+exports.newsletterSchema = newsletterSchema;

package/dist/packages/stack/src/plugins/newsletter/db.mjs

@@ -0,0 +1,55 @@
+import { createDbPlugin } from '@btst/db';
+
+const newsletterSchema = createDbPlugin("newsletter", {
+  subscriber: {
+    modelName: "newsletterSubscriber",
+    fields: {
+      email: { type: "string", required: true, unique: true },
+      name: { type: "string", required: false },
+      status: { type: "string", defaultValue: "subscribed" },
+      transactionOnly: { type: "boolean", defaultValue: false },
+      tags: { type: "string", defaultValue: "[]" },
+      confirmedAt: { type: "date", required: false },
+      createdAt: { type: "date", defaultValue: () => /* @__PURE__ */ new Date() },
+      confirmationToken: { type: "string", required: false },
+      confirmationExpiresAt: { type: "date", required: false },
+      confirmationSentAt: { type: "date", required: false }
+    }
+  },
+  campaign: {
+    modelName: "newsletterCampaign",
+    fields: {
+      subject: { type: "string", required: true },
+      fromName: { type: "string", required: true },
+      fromEmail: { type: "string", required: true },
+      replyTo: { type: "string", required: false },
+      body: { type: "string", required: true },
+      format: { type: "string", defaultValue: "markdown" },
+      tags: { type: "string", defaultValue: "[]" },
+      status: { type: "string", defaultValue: "draft" },
+      scheduledAt: { type: "date", required: false },
+      sentAt: { type: "date", required: false },
+      createdAt: { type: "date", defaultValue: () => /* @__PURE__ */ new Date() },
+      updatedAt: { type: "date", defaultValue: () => /* @__PURE__ */ new Date() }
+    }
+  },
+  send: {
+    modelName: "newsletterSend",
+    fields: {
+      key: { type: "string", required: true, unique: true },
+      campaignId: { type: "string", required: true },
+      subscriberId: { type: "string", required: true },
+      email: { type: "string", required: true },
+      status: { type: "string", defaultValue: "pending" },
+      trackingToken: { type: "string", required: true, unique: true },
+      unsubscribeToken: { type: "string", required: true, unique: true },
+      links: { type: "string", defaultValue: "[]" },
+      messageId: { type: "string", required: false },
+      sentAt: { type: "date", required: false },
+      openedAt: { type: "date", required: false },
+      clickedAt: { type: "date", required: false }
+    }
+  }
+});
+
+export { newsletterSchema };

package/dist/packages/stack/src/plugins/newsletter/schemas.cjs

@@ -0,0 +1,87 @@
+'use strict';
+
+const z = require('zod');
+
+const header = z.z.string().trim().min(1).max(500).refine(
+  (value) => !/[\r\n]/.test(value),
+  "Email headers must not contain line breaks"
+);
+const subscriberStatusSchema = z.z.enum([
+  "subscribed",
+  "unsubscribed",
+  "bounced"
+]);
+const tagsSchema = z.z.array(z.z.string().trim().min(1).max(100)).max(50).default([]);
+const emailSchema = z.z.email().max(320).transform((email) => email.trim().toLowerCase());
+const subscribeSchema = z.z.object({
+  email: emailSchema,
+  name: z.z.string().trim().max(200).optional(),
+  tags: tagsSchema
+});
+const createSubscriberSchema = subscribeSchema.extend({
+  status: subscriberStatusSchema.default("subscribed")
+});
+const updateSubscriberSchema = createSubscriberSchema.partial().extend({
+  tags: tagsSchema.removeDefault().optional(),
+  status: subscriberStatusSchema.optional()
+});
+const listSubscribersSchema = z.z.object({
+  limit: z.z.coerce.number().int().min(1).max(200).default(50),
+  offset: z.z.coerce.number().int().min(0).default(0),
+  query: z.z.string().max(200).optional(),
+  status: subscriberStatusSchema.optional(),
+  tag: z.z.string().max(100).optional()
+});
+const listCampaignsSchema = z.z.object({
+  limit: z.z.coerce.number().int().min(1).max(200).default(50),
+  offset: z.z.coerce.number().int().min(0).default(0)
+});
+const createCampaignSchema = z.z.object({
+  subject: header,
+  fromName: header.max(200),
+  fromEmail: emailSchema,
+  replyTo: emailSchema.optional(),
+  body: z.z.string().min(1).max(1e6),
+  format: z.z.enum(["markdown", "html"]).default("markdown"),
+  tags: tagsSchema
+});
+const updateCampaignSchema = createCampaignSchema.partial().extend({
+  replyTo: emailSchema.nullable().optional(),
+  tags: tagsSchema.removeDefault().optional(),
+  format: z.z.enum(["markdown", "html"]).optional()
+});
+const idSchema = z.z.object({ id: z.z.string().min(1).max(200) });
+const tokenSchema = z.z.object({
+  token: z.z.string().regex(/^[a-f0-9]{64}$/)
+});
+const scheduleCampaignSchema = z.z.object({
+  scheduledAt: z.z.iso.datetime({ offset: true })
+});
+const testCampaignSchema = z.z.object({ email: emailSchema });
+const importSubscribersSchema = z.z.object({
+  csv: z.z.string().min(1).max(2e6)
+});
+const transactionalEmailSchema = z.z.object({
+  to: emailSchema,
+  subject: header,
+  html: z.z.string().min(1).max(1e6),
+  from: header,
+  replyTo: emailSchema.optional()
+});
+
+exports.createCampaignSchema = createCampaignSchema;
+exports.createSubscriberSchema = createSubscriberSchema;
+exports.emailSchema = emailSchema;
+exports.idSchema = idSchema;
+exports.importSubscribersSchema = importSubscribersSchema;
+exports.listCampaignsSchema = listCampaignsSchema;
+exports.listSubscribersSchema = listSubscribersSchema;
+exports.scheduleCampaignSchema = scheduleCampaignSchema;
+exports.subscribeSchema = subscribeSchema;
+exports.subscriberStatusSchema = subscriberStatusSchema;
+exports.tagsSchema = tagsSchema;
+exports.testCampaignSchema = testCampaignSchema;
+exports.tokenSchema = tokenSchema;
+exports.transactionalEmailSchema = transactionalEmailSchema;
+exports.updateCampaignSchema = updateCampaignSchema;
+exports.updateSubscriberSchema = updateSubscriberSchema;

package/dist/packages/stack/src/plugins/newsletter/schemas.mjs

@@ -0,0 +1,70 @@
+import { z } from 'zod';
+
+const header = z.string().trim().min(1).max(500).refine(
+  (value) => !/[\r\n]/.test(value),
+  "Email headers must not contain line breaks"
+);
+const subscriberStatusSchema = z.enum([
+  "subscribed",
+  "unsubscribed",
+  "bounced"
+]);
+const tagsSchema = z.array(z.string().trim().min(1).max(100)).max(50).default([]);
+const emailSchema = z.email().max(320).transform((email) => email.trim().toLowerCase());
+const subscribeSchema = z.object({
+  email: emailSchema,
+  name: z.string().trim().max(200).optional(),
+  tags: tagsSchema
+});
+const createSubscriberSchema = subscribeSchema.extend({
+  status: subscriberStatusSchema.default("subscribed")
+});
+const updateSubscriberSchema = createSubscriberSchema.partial().extend({
+  tags: tagsSchema.removeDefault().optional(),
+  status: subscriberStatusSchema.optional()
+});
+const listSubscribersSchema = z.object({
+  limit: z.coerce.number().int().min(1).max(200).default(50),
+  offset: z.coerce.number().int().min(0).default(0),
+  query: z.string().max(200).optional(),
+  status: subscriberStatusSchema.optional(),
+  tag: z.string().max(100).optional()
+});
+const listCampaignsSchema = z.object({
+  limit: z.coerce.number().int().min(1).max(200).default(50),
+  offset: z.coerce.number().int().min(0).default(0)
+});
+const createCampaignSchema = z.object({
+  subject: header,
+  fromName: header.max(200),
+  fromEmail: emailSchema,
+  replyTo: emailSchema.optional(),
+  body: z.string().min(1).max(1e6),
+  format: z.enum(["markdown", "html"]).default("markdown"),
+  tags: tagsSchema
+});
+const updateCampaignSchema = createCampaignSchema.partial().extend({
+  replyTo: emailSchema.nullable().optional(),
+  tags: tagsSchema.removeDefault().optional(),
+  format: z.enum(["markdown", "html"]).optional()
+});
+const idSchema = z.object({ id: z.string().min(1).max(200) });
+const tokenSchema = z.object({
+  token: z.string().regex(/^[a-f0-9]{64}$/)
+});
+const scheduleCampaignSchema = z.object({
+  scheduledAt: z.iso.datetime({ offset: true })
+});
+const testCampaignSchema = z.object({ email: emailSchema });
+const importSubscribersSchema = z.object({
+  csv: z.string().min(1).max(2e6)
+});
+const transactionalEmailSchema = z.object({
+  to: emailSchema,
+  subject: header,
+  html: z.string().min(1).max(1e6),
+  from: header,
+  replyTo: emailSchema.optional()
+});
+
+export { createCampaignSchema, createSubscriberSchema, emailSchema, idSchema, importSubscribersSchema, listCampaignsSchema, listSubscribersSchema, scheduleCampaignSchema, subscribeSchema, subscriberStatusSchema, tagsSchema, testCampaignSchema, tokenSchema, transactionalEmailSchema, updateCampaignSchema, updateSubscriberSchema };

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

@@ -0,0 +1,216 @@
+'use strict';
+
+const schemas = require('../schemas.cjs');
+const records = require('./records.cjs');
+const serializers = require('./serializers.cjs');
+
+const whereId = (id) => [
+  { field: "id", value: id, operator: "eq" }
+];
+const whereField = (field, value) => [
+  { field, value, operator: "eq" }
+];
+async function listSections(adapter, courseId) {
+  return (await records.findAllSchoolRecords(adapter, {
+    model: "schoolSection",
+    where: whereField("courseId", courseId)
+  })).sort((left, right) => left.order - right.order);
+}
+function parseLesson(lesson) {
+  return {
+    ...lesson,
+    resources: JSON.parse(lesson.resources),
+    quiz: lesson.quiz ? JSON.parse(lesson.quiz) : null
+  };
+}
+async function listLessons(adapter, courseId) {
+  const lessons = await records.findAllSchoolRecords(adapter, {
+    model: "schoolLesson",
+    where: whereField("courseId", courseId)
+  });
+  const sections = await listSections(adapter, courseId);
+  const sectionRanks = new Map(
+    sections.map((section, index) => [section.id, index])
+  );
+  lessons.sort(
+    (left, right) => (sectionRanks.get(left.sectionId ?? "") ?? sections.length) - (sectionRanks.get(right.sectionId ?? "") ?? sections.length) || left.order - right.order
+  );
+  return lessons.map(parseLesson);
+}
+async function getLesson(adapter, id) {
+  const lesson = await adapter.findOne({
+    model: "schoolLesson",
+    where: whereId(id)
+  });
+  return lesson ? parseLesson(lesson) : null;
+}
+function lessonSummary(lesson) {
+  const {
+    id,
+    courseId,
+    title,
+    sectionId,
+    type,
+    durationMins,
+    order,
+    isFreePreview
+  } = lesson;
+  return {
+    id,
+    courseId,
+    title,
+    sectionId,
+    type,
+    durationMins,
+    order,
+    isFreePreview
+  };
+}
+function publicLesson(lesson) {
+  return {
+    ...lesson,
+    quiz: lesson.quiz ? {
+      ...lesson.quiz,
+      questions: lesson.quiz.questions.map((q) => {
+        const { correctAnswer: _answer, ...publicQuestion } = q;
+        return publicQuestion;
+      })
+    } : null
+  };
+}
+async function getStoredCourses(adapter) {
+  const type = await adapter.findOne({
+    model: "contentType",
+    where: whereField("slug", "school-course")
+  });
+  if (!type) return [];
+  const records$1 = await records.findAllSchoolRecords(adapter, {
+    model: "contentItem",
+    where: whereField("contentTypeId", type.id)
+  });
+  const result = [];
+  for (const record of records$1) {
+    const course = await courseFromRecord(adapter, record);
+    if (course) result.push(course);
+  }
+  return result;
+}
+async function listCourses(adapter, filters = {}) {
+  const items = (await getStoredCourses(adapter)).filter(
+    (course) => course.status === "published" && (!filters.category || course.category === filters.category) && (!filters.difficulty || course.difficulty === filters.difficulty) && (filters.maxDurationMins === void 0 || course.durationMins <= Number(filters.maxDurationMins)) && (!filters.pricing || (filters.pricing === "free" ? course.price === 0 : course.price > 0)) && (filters.featured === void 0 || course.featured === (filters.featured === true || filters.featured === "true")) && (!filters.query || `${course.title} ${course.description} ${course.tags.join(" ")}`.toLowerCase().includes(filters.query.toLowerCase()))
+  );
+  return { items, total: items.length };
+}
+async function courseFromRecord(adapter, record) {
+  const parsed = schemas.courseSchema.safeParse(JSON.parse(record.data));
+  if (!parsed.success) return null;
+  return {
+    ...parsed.data,
+    id: record.id,
+    createdAt: new Date(record.createdAt).toISOString(),
+    updatedAt: new Date(record.updatedAt).toISOString(),
+    lessonCount: (await listLessons(adapter, record.id)).length
+  };
+}
+async function getCourse(adapter, id) {
+  const type = await adapter.findOne({
+    model: "contentType",
+    where: whereField("slug", "school-course")
+  });
+  if (!type) return null;
+  const record = await adapter.findOne({
+    model: "contentItem",
+    where: whereId(id)
+  });
+  if (!record || record.contentTypeId !== type.id) return null;
+  return courseFromRecord(adapter, record);
+}
+async function getCourseBySlug(adapter, slug) {
+  return (await getStoredCourses(adapter)).find(
+    (course) => course.slug === slug && course.status === "published"
+  ) ?? null;
+}
+async function listReviews(adapter, courseId) {
+  return serializers.serializeSchoolRecord(
+    await records.findAllSchoolRecords(adapter, {
+      model: "schoolReview",
+      where: whereField("courseId", courseId)
+    })
+  );
+}
+async function getCourseDetail(adapter, course) {
+  return {
+    ...course,
+    sections: await listSections(adapter, course.id),
+    lessons: (await listLessons(adapter, course.id)).map(lessonSummary),
+    reviews: await listReviews(adapter, course.id),
+    enrollment: null
+  };
+}
+async function getEnrollment(adapter, courseId, userId) {
+  return serializers.serializeSchoolRecord(
+    await adapter.findOne({
+      model: "schoolEnrollment",
+      where: [
+        ...whereField("courseId", courseId),
+        ...whereField("userId", userId)
+      ]
+    })
+  );
+}
+async function getProgress(adapter, enrollmentId, lessonId) {
+  return serializers.serializeSchoolRecord(
+    await adapter.findOne({
+      model: "schoolLessonProgress",
+      where: [
+        ...whereField("enrollmentId", enrollmentId),
+        ...whereField("lessonId", lessonId)
+      ]
+    })
+  );
+}
+async function getQuizAttempts(adapter, lessonId, userId) {
+  const records$1 = await records.findAllSchoolRecords(adapter, {
+    model: "schoolQuizAttempt",
+    where: [
+      ...whereField("lessonId", lessonId),
+      ...whereField("userId", userId)
+    ]
+  });
+  records$1.sort(
+    (left, right) => new Date(right.attemptedAt).getTime() - new Date(left.attemptedAt).getTime()
+  );
+  return serializers.serializeSchoolRecord(
+    records$1.map((record) => ({
+      ...record,
+      answers: JSON.parse(record.answers)
+    }))
+  );
+}
+async function getEnrollments(adapter, field, id) {
+  return serializers.serializeSchoolRecord(
+    await records.findAllSchoolRecords(adapter, {
+      model: "schoolEnrollment",
+      where: whereField(field, id)
+    })
+  );
+}
+
+exports.getCourse = getCourse;
+exports.getCourseBySlug = getCourseBySlug;
+exports.getCourseDetail = getCourseDetail;
+exports.getEnrollment = getEnrollment;
+exports.getEnrollments = getEnrollments;
+exports.getLesson = getLesson;
+exports.getProgress = getProgress;
+exports.getQuizAttempts = getQuizAttempts;
+exports.getStoredCourses = getStoredCourses;
+exports.lessonSummary = lessonSummary;
+exports.listCourses = listCourses;
+exports.listLessons = listLessons;
+exports.listReviews = listReviews;
+exports.listSections = listSections;
+exports.parseLesson = parseLesson;
+exports.publicLesson = publicLesson;
+exports.whereField = whereField;
+exports.whereId = whereId;