@playcademy/vite-plugin 1.2.1-beta.21 → 1.2.1-beta.22

package/dist/index.js

@@ -24315,7 +24315,7 @@ import path2 from "node:path";
 // package.json
 var package_default = {
   name: "@playcademy/vite-plugin",
-  version: "1.2.1-beta.21",
+  version: "1.2.1-beta.22",
   type: "module",
   exports: {
     ".": {
@@ -25921,7 +25921,7 @@ var package_default2;
 var init_package = __esm(() => {
   package_default2 = {
     name: "@playcademy/sandbox",
-    version: "0.7.1-beta.20",
+    version: "0.7.1-beta.21",
     description: "Local development server for Playcademy game development",
     type: "module",
     exports: {
@@ -64252,6 +64252,8 @@ var AssessmentStandardRefSchema2;
 var CreateAssessmentRequestSchema;
 var UpdateAssessmentRequestSchema;
 var CopyAssessmentRequestSchema;
+var AssessmentAssociationImportEntrySchema;
+var AttachExistingAssessmentsRequestSchema;
 var ReorderAssessmentsRequestSchema;
 var ReorderQuestionsRequestSchema;
 var init_schemas4 = __esm(() => {
@@ -64520,6 +64522,43 @@ var init_schemas4 = __esm(() => {
     purpose: AssessmentPurposeSchema,
     standard: AssessmentStandardRefSchema2.optional()
   }).superRefine(requireMasteryStandard);
+  AssessmentAssociationImportEntrySchema = exports_external.object({
+    qtiTestIdentifier: exports_external.string().trim().min(1, "Assessment identifier is required"),
+    purpose: AssessmentPurposeSchema,
+    standard: AssessmentStandardRefSchema2.optional(),
+    sortOrder: exports_external.number().int().nonnegative().nullable()
+  }).superRefine((input, context2) => {
+    requireMasteryStandard(input, context2);
+    if (input.purpose !== "mastery" && input.standard !== undefined) {
+      context2.addIssue({
+        code: "custom",
+        path: ["standard"],
+        message: "Only mastery assessments may have a quiz-level standard"
+      });
+    }
+  });
+  AttachExistingAssessmentsRequestSchema = exports_external.object({
+    version: exports_external.literal(1),
+    sourceGameId: exports_external.string().trim().min(1),
+    sourceGameSlug: exports_external.string().trim().min(1).optional(),
+    sourceIntegrationId: exports_external.string().trim().min(1),
+    subject: TimebackSubjectSchema,
+    grade: TimebackGradeSchema,
+    targetStatus: exports_external.enum(["draft", "live"]),
+    assessments: exports_external.array(AssessmentAssociationImportEntrySchema).min(1, "At least one assessment is required").max(500, "A bulk import can contain at most 500 assessments")
+  }).superRefine((input, context2) => {
+    const seen = new Set;
+    input.assessments.forEach((assessment, index2) => {
+      if (seen.has(assessment.qtiTestIdentifier)) {
+        context2.addIssue({
+          code: "custom",
+          path: ["assessments", index2, "qtiTestIdentifier"],
+          message: "Assessment identifiers must be unique"
+        });
+      }
+      seen.add(assessment.qtiTestIdentifier);
+    });
+  });
   ReorderAssessmentsRequestSchema = exports_external.object({
     purpose: AssessmentPurposeSchema,
     testIdentifiers: exports_external.array(exports_external.string().trim().min(1, "Assessment identifier is required")).min(1, "At least one assessment is required")
@@ -120014,6 +120053,74 @@ var init_timeback_qti_authoring_util = __esm(() => {
     buildMatchQuestionXml
   ];
 });
+function assertPlayableAssessmentImportQuestions(targetStatus, questions) {
+  if (targetStatus === "draft") {
+    return;
+  }
+  for (const question of questions) {
+    assertPlayableQtiQuestion(question);
+  }
+}
+function assertAssessmentImportCourseMatches(manifest, integration) {
+  if (integration.subject !== manifest.subject || integration.grade !== manifest.grade) {
+    throw new ValidationError(`This manifest is for ${manifest.subject} grade ${manifest.grade}, not ${integration.subject} grade ${integration.grade}.`);
+  }
+}
+function associationMetadataMatches(row, entry2) {
+  return row.purpose === entry2.purpose && (row.standardFramework ?? undefined) === entry2.standard?.framework && (row.standardIdentifier ?? undefined) === entry2.standard?.identifier;
+}
+function targetStatusSatisfied(row, targetStatus) {
+  return row.status === targetStatus || targetStatus === "draft" && row.status === "live";
+}
+function classifyExistingAssessmentImport(row, entry2, targetStatus) {
+  if (!associationMetadataMatches(row, entry2)) {
+    return {
+      status: "failed",
+      message: "Already attached with different purpose or standard metadata."
+    };
+  }
+  if (targetStatusSatisfied(row, targetStatus)) {
+    return { status: "skipped", message: `Already attached as ${row.status}.` };
+  }
+  if (row.status === "archived") {
+    return {
+      status: "failed",
+      message: "Already attached as archived and cannot be imported again."
+    };
+  }
+  if (targetStatus === "live" && row.status === "draft") {
+    return {
+      status: "failed",
+      message: "Already attached as a draft. Publish it from the assessment editor before retrying."
+    };
+  }
+  return {
+    status: "failed",
+    message: `Already attached as ${row.status}, which does not match the requested ${targetStatus} status.`
+  };
+}
+function attachedAssessmentImportMessage(targetStatus, editable) {
+  if (targetStatus === "live") {
+    return editable ? "Attached live." : "Attached live. QTI content is read-only because another app owns it.";
+  }
+  return editable ? "Attached as a draft." : "Attached as a read-only draft owned by another app.";
+}
+function liveReviewAssessmentImportFailures(targetStatus, candidates, existingRows) {
+  if (targetStatus === "draft") {
+    return new Map;
+  }
+  const reviews = candidates.filter((candidate) => candidate.purpose === "review");
+  const hasExistingLiveReview = existingRows.some((row) => row.purpose === "review" && row.status === "live");
+  if (reviews.length <= 1 && !hasExistingLiveReview) {
+    return new Map;
+  }
+  const message = hasExistingLiveReview ? "Another review assessment is already live for this course." : "Only one review assessment can be imported live at a time.";
+  return new Map(reviews.map((review) => [review.qtiTestIdentifier, message]));
+}
+var init_timeback_assessment_import_util = __esm(() => {
+  init_errors2();
+  init_timeback_qti_authoring_util();
+});
 function newPlaycademyTestIdentifier() {
   return `${PLAYCADEMY_QTI_SOURCE_PREFIX}${crypto.randomUUID()}`;
 }
@@ -120160,6 +120267,150 @@ class TimebackAssessmentsService {
       throw error88;
     }
   }
+  async attachExistingAssessments(integrationId, manifest) {
+    const client2 = this.requireClient();
+    const { integration, gameSlug } = await this.requireQtiTestOwnershipContext(integrationId);
+    assertAssessmentImportCourseMatches(manifest, integration);
+    validateUniqueAssessmentIdentifiers(manifest.assessments.map((assessment) => assessment.qtiTestIdentifier));
+    const entries = manifest.assessments.map((assessment, index2) => ({
+      ...assessment,
+      index: index2,
+      standard: this.requirePurposeStandard(assessment.purpose, assessment.standard)
+    }));
+    const existingRows = await this.deps.db.query.gameTimebackAssessmentTests.findMany({
+      where: eq(gameTimebackAssessmentTests.integrationId, integrationId)
+    });
+    const existingByIdentifier = new Map(existingRows.map((row) => [row.qtiTestIdentifier, row]));
+    const validated = await runWithConcurrency(entries, QTI_HYDRATION_CONCURRENCY, async (entry2) => {
+      try {
+        const loaded = await loadHydratedQtiTest(client2, entry2.qtiTestIdentifier);
+        assertAssessmentHasQuestions(loaded.questions.questions);
+        assertPlayableAssessmentImportQuestions(manifest.targetStatus, loaded.questions.questions.map(({ question }) => question));
+        if (entry2.purpose === "review") {
+          assertReviewAssessmentHasStandards(loaded.questions.questions.map(({ question }) => qtiAssessmentStandardRefsFromMetadata2(question.metadata).filter((standard) => canonicalReviewStandardRef(standard) !== null).length));
+        }
+        return { entry: entry2, test: loaded.test };
+      } catch (error88) {
+        return { entry: entry2, error: error88 };
+      }
+    });
+    const results = [];
+    const pending = [];
+    for (const validation of validated) {
+      const { entry: entry2 } = validation;
+      const { index: index2 } = entry2;
+      const base = {
+        qtiTestIdentifier: entry2.qtiTestIdentifier,
+        purpose: entry2.purpose,
+        ...entry2.standard ? { standard: entry2.standard } : {},
+        sourceSortOrder: entry2.sortOrder
+      };
+      if ("error" in validation) {
+        results[index2] = {
+          ...base,
+          status: "failed",
+          message: `QTI validation failed: ${errorMessage2(validation.error)}`
+        };
+      } else {
+        const existing = existingByIdentifier.get(entry2.qtiTestIdentifier);
+        const editable = isQtiTestOwnedByGame(validation.test, gameSlug);
+        const hydratedBase = { ...base, title: validation.test.title, editable };
+        if (!existing) {
+          pending.push({ entry: entry2, test: validation.test });
+        } else {
+          const decision = classifyExistingAssessmentImport(existing, {
+            purpose: entry2.purpose,
+            ...entry2.standard ? { standard: entry2.standard } : {}
+          }, manifest.targetStatus);
+          results[index2] = {
+            ...hydratedBase,
+            status: decision.status,
+            association: this.associationImportSummary(existing),
+            message: decision.message
+          };
+        }
+      }
+    }
+    const liveReviewFailures = liveReviewAssessmentImportFailures(manifest.targetStatus, pending.map(({ entry: entry2 }) => entry2), existingRows);
+    for (const { entry: entry2, test } of pending) {
+      const message = liveReviewFailures.get(entry2.qtiTestIdentifier);
+      if (message) {
+        results[entry2.index] = {
+          qtiTestIdentifier: entry2.qtiTestIdentifier,
+          title: test.title,
+          purpose: entry2.purpose,
+          ...entry2.standard ? { standard: entry2.standard } : {},
+          sourceSortOrder: entry2.sortOrder,
+          editable: isQtiTestOwnedByGame(test, gameSlug),
+          status: "failed",
+          message
+        };
+      }
+    }
+    const attachablePending = pending.filter(({ entry: entry2 }) => !liveReviewFailures.has(entry2.qtiTestIdentifier));
+    for (const validation of attachablePending) {
+      const { entry: entry2, test } = validation;
+      const { index: index2 } = entry2;
+      const base = {
+        qtiTestIdentifier: entry2.qtiTestIdentifier,
+        title: test.title,
+        purpose: entry2.purpose,
+        ...entry2.standard ? { standard: entry2.standard } : {},
+        sourceSortOrder: entry2.sortOrder,
+        editable: isQtiTestOwnedByGame(test, gameSlug)
+      };
+      try {
+        const [row] = await this.deps.db.insert(gameTimebackAssessmentTests).values({
+          integrationId,
+          qtiTestIdentifier: entry2.qtiTestIdentifier,
+          purpose: entry2.purpose,
+          status: manifest.targetStatus,
+          sortOrder: entry2.sortOrder,
+          standardFramework: entry2.standard?.framework,
+          standardIdentifier: entry2.standard?.identifier
+        }).returning();
+        if (!row) {
+          throw new Error("Assessment association create returned no row");
+        }
+        results[index2] = {
+          ...base,
+          status: "created",
+          association: this.associationImportSummary(row),
+          message: attachedAssessmentImportMessage(manifest.targetStatus, base.editable)
+        };
+      } catch (error88) {
+        results[index2] = {
+          ...base,
+          status: "failed",
+          message: `Association attach failed: ${errorMessage2(error88)}`
+        };
+        if (isUniqueViolation(error88)) {
+          let concurrentAssociation;
+          try {
+            concurrentAssociation = await this.deps.db.query.gameTimebackAssessmentTests.findFirst({
+              where: and(eq(gameTimebackAssessmentTests.integrationId, integrationId), eq(gameTimebackAssessmentTests.qtiTestIdentifier, entry2.qtiTestIdentifier))
+            });
+          } catch {}
+          if (concurrentAssociation) {
+            const decision = classifyExistingAssessmentImport(concurrentAssociation, {
+              purpose: entry2.purpose,
+              ...entry2.standard ? { standard: entry2.standard } : {}
+            }, manifest.targetStatus);
+            results[index2] = {
+              ...base,
+              status: decision.status,
+              association: this.associationImportSummary(concurrentAssociation),
+              message: decision.message
+            };
+          }
+        }
+      }
+    }
+    setAttribute("app.assessment.operation", "bulk_attach_existing");
+    setAttribute("app.assessment.bulk_attach.target_status", manifest.targetStatus);
+    setAttribute("app.assessment.bulk_attach.created", results.filter((result) => result.status === "created").length);
+    return { results };
+  }
   async updateAssessment(integrationId, qtiTestIdentifier, input) {
     try {
       return await this.withLockedAssessmentAssociations(integrationId, qtiTestIdentifier, async (row, tx, associations) => {
@@ -120673,6 +120924,13 @@ class TimebackAssessmentsService {
       updatedAt: row.updatedAt
     };
   }
+  associationImportSummary(row) {
+    return {
+      ...this.associationSummary(row),
+      createdAt: row.createdAt.toISOString(),
+      updatedAt: row.updatedAt.toISOString()
+    };
+  }
   canonicalAssessmentStandard(input) {
     const standard = canonicalReviewStandardRef(input);
     if (!standard) {
@@ -120719,6 +120977,7 @@ var init_timeback_assessments_service = __esm(async () => {
   init_qti();
   init_timeback3();
   init_errors2();
+  init_timeback_assessment_import_util();
   init_timeback_assessment_rules_util();
   init_timeback_qti_authoring_util();
   init_timeback_qti_hydration_util();
@@ -183335,6 +183594,7 @@ var unenrollStudent;
 var reactivateEnrollment;
 var listAssessments;
 var createAssessment;
+var attachExistingAssessments;
 var updateAssessment;
 var reorderAssessments;
 var reorderQuestions;
@@ -184001,6 +184261,15 @@ var init_timeback_controller = __esm(() => {
       qtiTestIdentifier
     });
   });
+  attachExistingAssessments = requireDeveloper(async (ctx) => {
+    const { gameId, courseId } = ctx.params;
+    if (!gameId || !courseId) {
+      throw ApiError.badRequest("Missing gameId or courseId parameter");
+    }
+    const manifest = await parseRequestBody(ctx.request, AttachExistingAssessmentsRequestSchema);
+    const integrationId = await ctx.services.timebackAssessments.resolveIntegrationId(gameId, courseId, ctx.user);
+    return ctx.services.timebackAssessments.attachExistingAssessments(integrationId, manifest);
+  });
   updateAssessment = requireDeveloper(async (ctx) => {
     const { gameId, courseId, testIdentifier } = ctx.params;
     if (!gameId || !courseId || !testIdentifier) {
@@ -184150,6 +184419,7 @@ var init_timeback_controller = __esm(() => {
     reactivateEnrollment,
     listAssessments,
     createAssessment,
+    attachExistingAssessments,
     updateAssessment,
     reorderAssessments,
     removeAssessment,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@playcademy/vite-plugin",
-    "version": "1.2.1-beta.21",
+    "version": "1.2.1-beta.22",
     "type": "module",
     "exports": {
         ".": {
@@ -19,14 +19,14 @@
     "dependencies": {
         "archiver": "^7.0.1",
         "picocolors": "^1.1.1",
-        "playcademy": "0.28.1-beta.21"
+        "playcademy": "0.28.1-beta.22"
     },
     "devDependencies": {
         "@electric-sql/pglite": "^0.3.16",
         "@inquirer/prompts": "^7.8.6",
         "@playcademy/constants": "0.0.1",
-        "@playcademy/sandbox": "0.7.1-beta.20",
-        "@playcademy/sdk": "0.16.1-beta.20",
+        "@playcademy/sandbox": "0.7.1-beta.21",
+        "@playcademy/sdk": "0.16.1-beta.21",
         "@playcademy/types": "0.0.1",
         "@playcademy/utils": "0.0.1",
         "@types/archiver": "^6.0.3",