pairit 0.3.1 → 0.3.3

package/dist/index.js

@@ -9806,10 +9806,131 @@ async function attachHtmlToCompiledConfig(configPath, compiled) {
   }
   return sources;
 }
+function listWorkspaceComponents(config) {
+  const pages = config.pages;
+  const pageList = Array.isArray(pages) ? pages.filter(isRecord) : isRecord(pages) ? Object.values(pages).filter(isRecord) : [];
+  const result = [];
+  for (const page of pageList) {
+    if (!Array.isArray(page.components))
+      continue;
+    for (const comp of page.components) {
+      if (!isRecord(comp) || comp.type !== "live-workspace")
+        continue;
+      const props = isRecord(comp.props) ? comp.props : {};
+      const id = typeof comp.id === "string" ? comp.id : "live-workspace";
+      result.push({ id, props });
+    }
+  }
+  return result;
+}
+async function resolveWorkspaceSchema(schema, componentId, configDir) {
+  if (typeof schema !== "string" || !schema.trim().endsWith(".json")) {
+    throw new Error(`live-workspace ${componentId}: schema must be a .json file`);
+  }
+  const absolutePath = path2.resolve(configDir, schema.trim());
+  const rel = path2.relative(configDir, absolutePath);
+  if (rel.startsWith("..") || path2.isAbsolute(rel)) {
+    throw new Error(`live-workspace ${componentId}: schema must stay inside the config directory`);
+  }
+  try {
+    JSON.parse(await readFile2(absolutePath, "utf8"));
+  } catch (error) {
+    throw new Error(`live-workspace ${componentId}: can't read schema ${schema}: ${error.message}`);
+  }
+  return absolutePath;
+}
+async function inspectWorkspaceFiles(configPath, config) {
+  const configDir = await resolveConfigDir(configPath);
+  const errors = [];
+  for (const comp of listWorkspaceComponents(config)) {
+    try {
+      if (comp.props.renderer !== undefined) {
+        await resolveHtmlSource(comp.props.renderer, comp.id, configDir);
+      }
+      if (comp.props.schema !== undefined) {
+        await resolveWorkspaceSchema(comp.props.schema, comp.id, configDir);
+      }
+    } catch (error) {
+      errors.push(error instanceof Error ? error.message : String(error));
+    }
+  }
+  if (errors.length)
+    throw new Error(errors.join(`
+`));
+}
+async function attachWorkspaceFilesToCompiledConfig(configPath, compiled) {
+  const configDir = await resolveConfigDir(configPath);
+  for (const comp of listWorkspaceComponents(compiled)) {
+    if (comp.props.renderer !== undefined) {
+      const resolved = await resolveHtmlSource(comp.props.renderer, comp.id, configDir);
+      comp.props.rendererHtml = await readFile2(resolved.absolutePath, "utf8");
+    }
+    if (comp.props.schema !== undefined) {
+      const schemaPath = await resolveWorkspaceSchema(comp.props.schema, comp.id, configDir);
+      comp.props.schema = JSON.parse(await readFile2(schemaPath, "utf8"));
+    }
+  }
+}
+
+// src/randomize-lint.ts
+function lintRandomization(config) {
+  const errors = [];
+  const groupSize = singleGroupSize(config);
+  const check = (where, settings) => {
+    if (settings.distribute !== true)
+      return;
+    if (settings.scope !== "group") {
+      errors.push(`${where}: distribute: true needs scope: group`);
+    }
+    const conditions = settings.conditions;
+    if (!Array.isArray(conditions) || conditions.length === 0) {
+      errors.push(`${where}: distribute: true needs a conditions list`);
+      return;
+    }
+    if (groupSize !== undefined && conditions.length !== groupSize) {
+      errors.push(`${where}: distribute: true needs one condition per group member (${conditions.length} conditions, groups of ${groupSize})`);
+    }
+  };
+  config.pages?.forEach((page, pageIndex) => {
+    const pageName = page.id ?? `pages[${pageIndex}]`;
+    page.onEnter?.forEach((action, actionIndex) => {
+      const a = action;
+      if (a?.type === "randomize") {
+        check(`${pageName}.onEnter[${actionIndex}]`, a);
+      }
+    });
+    page.components?.forEach((component, componentIndex) => {
+      const c = component;
+      if (c?.type === "randomization" && c.props) {
+        check(`${pageName}.components[${componentIndex}]`, c.props);
+      }
+    });
+  });
+  return errors;
+}
+function singleGroupSize(config) {
+  const sizes = new Set;
+  if (Array.isArray(config.matchmaking)) {
+    for (const pool of config.matchmaking) {
+      const size = pool?.num_users;
+      sizes.add(typeof size === "number" ? size : 2);
+    }
+  }
+  for (const page of config.pages ?? []) {
+    for (const component of page.components ?? []) {
+      const c = component;
+      if (c?.type !== "matchmaking" || c.props?.poolId !== undefined)
+        continue;
+      const size = c.props?.num_users;
+      sizes.add(typeof size === "number" ? size : 2);
+    }
+  }
+  return sizes.size === 1 ? [...sizes][0] : undefined;
+}
 
 // src/index.ts
 var program2 = new Command;
-program2.name("pairit").description("CLI for Pairit experiment configs").version("0.3.1").option("--env <name>", "Target environment: staging or production", (value) => {
+program2.name("pairit").description("CLI for Pairit experiment configs").version("0.3.3").option("--env <name>", "Target environment: staging or production", (value) => {
   try {
     return parseEnvName(value);
   } catch (error) {
@@ -10101,9 +10222,11 @@ async function lintConfig(configPath) {
       });
     });
   }
+  errors.push(...lintRandomization(config));
   if (errors.length) {
     throw new Error(errors.join(", "));
   }
+  await inspectWorkspaceFiles(configPath, config);
   return inspectHtmlSources(configPath, config);
 }
 async function compileConfig(configPath) {
@@ -10162,12 +10285,17 @@ async function compileConfig(configPath) {
 }
 async function buildUploadPayload(configPath, options) {
   const sourceConfig = await loadConfig(configPath);
+  const randomizationErrors = lintRandomization(sourceConfig);
+  if (randomizationErrors.length) {
+    throw new Error(randomizationErrors.join(", "));
+  }
   const allowRetake = sourceConfig.allowRetake === true;
   const requireAuth = sourceConfig.requireAuth;
   const compiledPath = await compileConfig(configPath);
   const compiledContent = await readFile3(compiledPath, "utf8");
   const parsed = JSON.parse(compiledContent);
   const attachments = await attachHtmlToCompiledConfig(configPath, parsed);
+  await attachWorkspaceFilesToCompiledConfig(configPath, parsed);
   const hashBuffer = createHash("sha256").update(JSON.stringify(parsed)).digest();
   const checksum = hashBuffer.toString("hex");
   const explicitName = options.name ?? sourceConfig.name;
@@ -10357,6 +10485,7 @@ async function exportData(configId, options) {
   await fetchAndWriteExport(`/data/${cfg}/groups`, path3.join(outDir, `${configId}-groups`), (r) => r.groups ?? [], format, (group) => group, "groups");
   await fetchAndWriteExport(`/data/${cfg}/survey-responses`, path3.join(outDir, `${configId}-survey-responses`), (r) => r.surveyResponses ?? [], format, flattenSurveyResponse, "survey responses");
   await fetchAndWriteExport(`/data/${cfg}/workspace-documents`, path3.join(outDir, `${configId}-workspace-documents`), (r) => r.workspaceDocuments ?? [], format, flattenWorkspaceDocument, "workspace documents");
+  await fetchAndWriteExport(`/data/${cfg}/workspace-updates`, path3.join(outDir, `${configId}-workspace-updates`), (r) => r.workspaceUpdates ?? [], format, (update) => update, "workspace updates");
   console.log(`
 Files written to: ${outDir}`);
 }
@@ -10411,13 +10540,21 @@ function flattenSurveyResponse(response) {
   return flattened;
 }
 function flattenWorkspaceDocument(doc) {
-  const { fields, ...rest } = doc;
-  const flattened = { ...rest };
+  const { fields, authorship, fieldAuthors, ...rest } = doc;
+  const flattened = {
+    ...rest,
+    authorship: serializeValue(authorship)
+  };
   if (fields && typeof fields === "object") {
     for (const [key, value] of Object.entries(fields)) {
       flattened[`fields.${key}`] = serializeValue(value);
     }
   }
+  if (fieldAuthors && typeof fieldAuthors === "object") {
+    for (const [key, origin] of Object.entries(fieldAuthors)) {
+      flattened[`fieldAuthors.${key}`] = origin;
+    }
+  }
   return flattened;
 }
 function serializeValue(value) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pairit",
-	"version": "0.3.1",
+	"version": "0.3.3",
 	"description": "CLI for the Pairit behavioral science experiment platform",
 	"type": "module",
 	"bin": {