timeback 0.1.0 → 0.1.1

package/dist/index.js

@@ -358,19 +358,255 @@ var SubjectTrackInput = z4.object({
   targetCourseId: z4.string(),
   metadata: z4.record(z4.string(), z4.unknown()).optional()
 });
+// ../types/src/zod/qti.ts
+import { z as z5 } from "zod/v4";
+var QtiAssessmentItemType = z5.enum([
+  "choice",
+  "text-entry",
+  "extended-text",
+  "inline-choice",
+  "match",
+  "order",
+  "associate",
+  "select-point",
+  "graphic-order",
+  "graphic-associate",
+  "graphic-gap-match",
+  "hotspot",
+  "hottext",
+  "slider",
+  "drawing",
+  "media",
+  "upload"
+]);
+var QtiCardinality = z5.enum(["single", "multiple", "ordered", "record"]);
+var QtiBaseType = z5.enum([
+  "identifier",
+  "boolean",
+  "integer",
+  "float",
+  "string",
+  "point",
+  "pair",
+  "directedPair",
+  "duration",
+  "file",
+  "uri"
+]);
+var QtiDifficulty = z5.enum(["easy", "medium", "hard"]);
+var QtiNavigationMode = z5.enum(["linear", "nonlinear"]);
+var QtiSubmissionMode = z5.enum(["individual", "simultaneous"]);
+var QtiShowHide = z5.enum(["show", "hide"]);
+var QtiValidationSchema = z5.enum(["test", "item", "stimulus"]);
+var QtiFeedbackType = z5.enum(["QUESTION", "LESSON"]);
+var QtiCorrectResponse = z5.object({
+  value: z5.array(z5.string())
+}).strict();
+var QtiResponseDeclaration = z5.object({
+  identifier: z5.string().min(1),
+  cardinality: QtiCardinality,
+  baseType: QtiBaseType.optional(),
+  correctResponse: QtiCorrectResponse
+}).strict();
+var QtiOutcomeDeclaration = z5.object({
+  identifier: z5.string().min(1),
+  cardinality: QtiCardinality,
+  baseType: QtiBaseType.optional()
+}).strict();
+var QtiTestOutcomeDeclaration = z5.object({
+  identifier: z5.string().min(1),
+  cardinality: QtiCardinality.optional(),
+  baseType: QtiBaseType,
+  normalMaximum: z5.number().optional(),
+  normalMinimum: z5.number().optional(),
+  defaultValue: z5.object({
+    value: z5.unknown().optional()
+  }).strict().optional()
+}).strict();
+var QtiInlineFeedback = z5.object({
+  outcomeIdentifier: z5.string().min(1),
+  variableIdentifier: z5.string().min(1)
+}).strict();
+var QtiResponseProcessing = z5.object({
+  templateType: z5.enum(["match_correct", "map_response"]),
+  responseDeclarationIdentifier: z5.string().min(1),
+  outcomeIdentifier: z5.string().min(1),
+  correctResponseIdentifier: z5.string().min(1),
+  incorrectResponseIdentifier: z5.string().min(1),
+  inlineFeedback: QtiInlineFeedback.optional()
+}).strict();
+var QtiLearningObjectiveSet = z5.object({
+  source: z5.string().min(1),
+  learningObjectiveIds: z5.array(z5.string())
+}).strict();
+var QtiItemMetadata = z5.object({
+  subject: z5.string().optional(),
+  grade: TimebackGrade.optional(),
+  difficulty: QtiDifficulty.optional(),
+  learningObjectiveSet: z5.array(QtiLearningObjectiveSet).optional()
+}).strict();
+var QtiModalFeedback = z5.object({
+  outcomeIdentifier: z5.string().min(1),
+  identifier: z5.string().min(1),
+  showHide: QtiShowHide,
+  content: z5.string(),
+  title: z5.string()
+}).strict();
+var QtiFeedbackInline = z5.object({
+  outcomeIdentifier: z5.string().min(1),
+  identifier: z5.string().min(1),
+  showHide: QtiShowHide,
+  content: z5.string(),
+  class: z5.array(z5.string())
+}).strict();
+var QtiFeedbackBlock = z5.object({
+  outcomeIdentifier: z5.string().min(1),
+  identifier: z5.string().min(1),
+  showHide: QtiShowHide,
+  content: z5.string(),
+  class: z5.array(z5.string())
+}).strict();
+var QtiStylesheet = z5.object({
+  href: z5.string().min(1),
+  type: z5.string().min(1)
+}).strict();
+var QtiCatalogInfo = z5.object({
+  id: z5.string().min(1),
+  support: z5.string(),
+  content: z5.string()
+}).strict();
+var QtiAssessmentItemCreateInput = z5.object({
+  identifier: z5.string().min(1),
+  title: z5.string().min(1),
+  type: QtiAssessmentItemType,
+  qtiVersion: z5.string().optional(),
+  timeDependent: z5.boolean().optional(),
+  adaptive: z5.boolean().optional(),
+  responseDeclarations: z5.array(QtiResponseDeclaration).optional(),
+  outcomeDeclarations: z5.array(QtiOutcomeDeclaration).optional(),
+  responseProcessing: QtiResponseProcessing.optional(),
+  metadata: QtiItemMetadata.optional(),
+  modalFeedback: z5.array(QtiModalFeedback).optional(),
+  feedbackInline: z5.array(QtiFeedbackInline).optional(),
+  feedbackBlock: z5.array(QtiFeedbackBlock).optional()
+}).strict();
+var QtiAssessmentItemUpdateInput = z5.object({
+  title: z5.string().min(1),
+  type: QtiAssessmentItemType,
+  qtiVersion: z5.string().optional(),
+  timeDependent: z5.boolean().optional(),
+  adaptive: z5.boolean().optional(),
+  responseDeclarations: z5.array(QtiResponseDeclaration).optional(),
+  outcomeDeclarations: z5.array(QtiOutcomeDeclaration).optional(),
+  responseProcessing: QtiResponseProcessing.optional(),
+  metadata: QtiItemMetadata.optional(),
+  modalFeedback: z5.array(QtiModalFeedback).optional(),
+  feedbackInline: z5.array(QtiFeedbackInline).optional(),
+  feedbackBlock: z5.array(QtiFeedbackBlock).optional(),
+  rawXml: z5.string(),
+  content: z5.record(z5.string(), z5.unknown())
+}).strict();
+var QtiAssessmentItemProcessResponseInput = z5.object({
+  response: z5.union([z5.string(), z5.array(z5.string())])
+}).strict();
+var QtiAssessmentItemRef = z5.object({
+  identifier: z5.string().min(1),
+  href: z5.union([z5.string(), z5.array(z5.string()), z5.array(z5.array(z5.string()))]).optional(),
+  sequence: z5.number().optional()
+}).strict();
+var QtiAssessmentSection = z5.object({
+  identifier: z5.string().min(1),
+  title: z5.string().min(1),
+  visible: z5.boolean(),
+  required: z5.boolean().optional(),
+  fixed: z5.boolean().optional(),
+  sequence: z5.number().optional(),
+  "qti-assessment-item-ref": z5.array(QtiAssessmentItemRef).optional()
+}).strict();
+var QtiTestPart = z5.object({
+  identifier: z5.string().min(1),
+  navigationMode: QtiNavigationMode,
+  submissionMode: QtiSubmissionMode,
+  "qti-assessment-section": z5.union([QtiAssessmentSection, z5.array(QtiAssessmentSection)])
+}).strict();
+var QtiAssessmentTestCreateInput = z5.object({
+  identifier: z5.string().min(1),
+  title: z5.string().min(1),
+  qtiVersion: z5.string().optional(),
+  toolName: z5.string().optional(),
+  toolVersion: z5.string().optional(),
+  timeLimit: z5.number().optional(),
+  maxAttempts: z5.number().optional(),
+  toolsEnabled: z5.record(z5.string(), z5.boolean()).optional(),
+  metadata: z5.record(z5.string(), z5.unknown()).optional(),
+  "qti-test-part": QtiTestPart,
+  "qti-outcome-declaration": z5.array(QtiTestOutcomeDeclaration).optional()
+}).strict();
+var QtiAssessmentTestUpdateInput = z5.object({
+  title: z5.string().min(1),
+  qtiVersion: z5.string().optional(),
+  toolName: z5.string().optional(),
+  toolVersion: z5.string().optional(),
+  timeLimit: z5.number().optional(),
+  maxAttempts: z5.number().optional(),
+  toolsEnabled: z5.record(z5.string(), z5.boolean()).optional(),
+  metadata: z5.record(z5.string(), z5.unknown()).optional(),
+  "qti-test-part": QtiTestPart,
+  "qti-outcome-declaration": z5.array(QtiTestOutcomeDeclaration).optional()
+}).strict();
+var QtiStimulusCreateInput = z5.object({
+  identifier: z5.string().min(1),
+  title: z5.string().min(1),
+  label: z5.string().optional(),
+  language: z5.string().optional(),
+  stylesheet: QtiStylesheet.optional(),
+  content: z5.string(),
+  catalogInfo: z5.array(QtiCatalogInfo).optional(),
+  toolName: z5.string().optional(),
+  toolVersion: z5.string().optional(),
+  metadata: z5.record(z5.string(), z5.unknown()).optional()
+}).strict();
+var QtiStimulusUpdateInput = z5.object({
+  title: z5.string().min(1),
+  label: z5.string().optional(),
+  language: z5.string().optional(),
+  stylesheet: QtiStylesheet.optional(),
+  content: z5.string(),
+  catalogInfo: z5.array(QtiCatalogInfo).optional(),
+  toolName: z5.string().optional(),
+  toolVersion: z5.string().optional(),
+  metadata: z5.record(z5.string(), z5.unknown()).optional()
+}).strict();
+var QtiValidateInput = z5.object({
+  xml: z5.string().optional(),
+  schema: QtiValidationSchema,
+  entityId: z5.string().optional()
+}).strict();
+var QtiValidateBatchInput = z5.object({
+  xml: z5.array(z5.string()),
+  schema: QtiValidationSchema,
+  entityIds: z5.array(z5.string())
+}).strict();
+var QtiLessonFeedbackInput = z5.object({
+  questionId: z5.string().optional(),
+  userId: z5.string().min(1),
+  feedback: z5.string().min(1),
+  lessonId: z5.string().min(1),
+  humanApproved: z5.boolean().optional()
+}).strict();
 // ../internal/cli-infra/src/credentials/store.ts
 import { homedir, platform as platform2 } from "node:os";
 import { join } from "node:path";
 
 // ../internal/cli-infra/src/credentials/schema.ts
-import { z as z5 } from "zod";
-var CredentialsSchema = z5.object({
-  clientId: z5.string().min(1, "Client ID is required"),
-  clientSecret: z5.string().min(1, "Client secret is required"),
-  email: z5.email("Valid email is required").optional()
+import { z as z6 } from "zod";
+var CredentialsSchema = z6.object({
+  clientId: z6.string().min(1, "Client ID is required"),
+  clientSecret: z6.string().min(1, "Client secret is required"),
+  email: z6.email("Valid email is required").optional()
 });
-var ClientIdSchema = z5.string().min(1, "Client ID is required").regex(/^[a-z0-9]+$/, "Client ID must contain only lowercase letters and numbers").length(26, "Client ID must be exactly 26 characters");
-var ClientSecretSchema = z5.string().min(1, "Client secret is required").regex(/^[a-z0-9]+$/, "Client secret must contain only lowercase letters and numbers").max(53, "Client secret must be less than 53 characters");
+var ClientIdSchema = z6.string().min(1, "Client ID is required").regex(/^[a-z0-9]+$/, "Client ID must contain only lowercase letters and numbers").length(26, "Client ID must be exactly 26 characters");
+var ClientSecretSchema = z6.string().min(1, "Client secret is required").regex(/^[a-z0-9]+$/, "Client secret must contain only lowercase letters and numbers").max(53, "Client secret must be less than 53 characters");
 
 // ../internal/cli-infra/src/credentials/store.ts
 function getConfigDir() {
@@ -1036,21 +1272,21 @@ function createIdentityHandlers(params) {
   };
 }
 // src/server/handlers/activity.ts
-import * as z6 from "zod";
-var activityMetricsSchema = z6.object({
-  totalQuestions: z6.number().int().nonnegative().optional(),
-  correctQuestions: z6.number().int().nonnegative().optional(),
-  xpEarned: z6.number().int().nonnegative().optional(),
-  masteredUnits: z6.number().int().nonnegative().optional()
+import * as z7 from "zod";
+var activityMetricsSchema = z7.object({
+  totalQuestions: z7.number().int().nonnegative().optional(),
+  correctQuestions: z7.number().int().nonnegative().optional(),
+  xpEarned: z7.number().int().nonnegative().optional(),
+  masteredUnits: z7.number().int().nonnegative().optional()
 });
-var activityEndPayloadSchema = z6.object({
-  id: z6.string().min(1),
-  name: z6.string().min(1),
-  courseCode: z6.string().min(1),
-  startedAt: z6.iso.datetime(),
-  endedAt: z6.iso.datetime(),
-  elapsedMs: z6.number().int().nonnegative(),
-  pausedMs: z6.number().int().nonnegative(),
+var activityEndPayloadSchema = z7.object({
+  id: z7.string().min(1),
+  name: z7.string().min(1),
+  courseCode: z7.string().min(1),
+  startedAt: z7.iso.datetime(),
+  endedAt: z7.iso.datetime(),
+  elapsedMs: z7.number().int().nonnegative(),
+  pausedMs: z7.number().int().nonnegative(),
   metrics: activityMetricsSchema
 });
 function createActivityHandler(config2) {

package/dist/server/adapters/nuxt.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Nuxt Adapter
+ *
+ * Adapts Timeback handlers for Nuxt 3.
+ * Supports both middleware-based (recommended) and route-based approaches.
+ *
+ * This adapter does NOT import h3 or nuxt - it uses minimal interfaces
+ * that are compatible with H3's event structure.
+ */
+import type { NuxtHandlerOptions, NuxtHandlers, NuxtLikeEvent, TimebackInput } from './types';
+/**
+ * Nuxt server middleware handler for Timeback.
+ *
+ * This is the **recommended** approach for Nuxt 3 integration.
+ * It intercepts requests at the middleware level before they reach route handlers.
+ *
+ * Returns a Response if the request matches a Timeback route, or undefined
+ * to let the request continue to other handlers.
+ *
+ * @param options - Handler options
+ * @returns Response from Timeback or undefined to continue
+ *
+ * @example
+ * ```typescript
+ * // server/middleware/timeback.ts
+ * import { timeback } from '~/lib/timeback'
+ * import { nuxtHandler } from 'timeback/nuxt'
+ *
+ * export default defineEventHandler(async (event) => {
+ *   const response = await nuxtHandler({
+ *     timeback,
+ *     event,
+ *   })
+ *
+ *   if (response) {
+ *     return response
+ *   }
+ * })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // server/middleware/timeback.ts - with custom callback path
+ * import { timeback } from '~/lib/timeback'
+ * import { nuxtHandler } from 'timeback/nuxt'
+ *
+ * export default defineEventHandler(async (event) => {
+ *   const response = await nuxtHandler({
+ *     timeback,
+ *     event,
+ *     callbackPath: '/api/auth/sso/callback/timeback',
+ *   })
+ *
+ *   if (response) {
+ *     return response
+ *   }
+ * })
+ * ```
+ */
+export declare function nuxtHandler<TEvent extends NuxtLikeEvent>(options: NuxtHandlerOptions<TEvent>): Promise<Response | undefined>;
+/**
+ * Convert Timeback instance to Nuxt route handlers.
+ *
+ * This is an **alternative** approach using Nuxt's catch-all route handlers.
+ * Use this if you prefer explicit route files over middleware.
+ *
+ * Accepts either the full Timeback instance or just the handlers:
+ * - `toNuxtHandler(timeback)`
+ * - `toNuxtHandler(timeback.handle)`
+ *
+ * @param input - Timeback instance or handlers, or options object
+ * @returns Object with HTTP method handlers for Nuxt
+ *
+ * @example
+ * ```typescript
+ * // server/api/timeback/[...timeback].ts
+ * import { timeback } from '~/lib/timeback'
+ * import { toNuxtHandler } from 'timeback/nuxt'
+ *
+ * const handlers = toNuxtHandler(timeback)
+ *
+ * export default defineEventHandler(async (event) => {
+ *   const method = event.request?.method ?? event.node?.req?.method ?? 'GET'
+ *   const handler = handlers[method as keyof typeof handlers]
+ *   if (handler) {
+ *     return handler(event)
+ *   }
+ *   return new Response('Method not allowed', { status: 405 })
+ * })
+ * ```
+ */
+export declare function toNuxtHandler(input: TimebackInput | {
+    timeback: TimebackInput;
+    callbackPath?: string;
+}): NuxtHandlers;
+//# sourceMappingURL=nuxt.d.ts.map

package/dist/server/adapters/nuxt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nuxt.d.ts","sourceRoot":"","sources":["../../../src/server/adapters/nuxt.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,OAAO,KAAK,EAEX,kBAAkB,EAClB,YAAY,EACZ,aAAa,EACb,aAAa,EACb,MAAM,SAAS,CAAA;AAsNhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,wBAAsB,WAAW,CAAC,MAAM,SAAS,aAAa,EAC7D,OAAO,EAAE,kBAAkB,CAAC,MAAM,CAAC,GACjC,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC,CA6C/B;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,aAAa,CAC5B,KAAK,EAAE,aAAa,GAAG;IAAE,QAAQ,EAAE,aAAa,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,GACvE,YAAY,CAqDd"}