@morscherlab/mint-sdk 1.2.0-beta.3 → 1.2.0-beta.4

package/src/templates/templateEnvelopes.ts

@@ -0,0 +1,137 @@
+import type {
+  BioTemplateEnvelope,
+  TemplateCollection,
+  TemplateCollectionEnvelope,
+  TemplateId,
+} from './types'
+import { isRecord } from './builderReadUtils'
+
+export const TEMPLATE_COLLECTION_KEY = 'templates'
+
+export function createTemplateEnvelope<TData>(
+  templateId: TemplateId,
+  data: TData,
+  metadata: Record<string, unknown> = {},
+  templateVersion = '1.0'
+): BioTemplateEnvelope<TData> {
+  return {
+    template_id: templateId,
+    template_version: templateVersion,
+    kind: 'experiment-design',
+    data,
+    metadata,
+  }
+}
+
+export function createTemplateCollection(
+  templates: Array<BioTemplateEnvelope<unknown>>,
+  metadata?: Record<string, unknown>
+): TemplateCollectionEnvelope {
+  const collection: TemplateCollection = {}
+  for (const template of templates) {
+    assertGenericTemplateEnvelope(template)
+    const templateId = template.template_id
+    if (collection[templateId]) {
+      throw new Error(`Duplicate template_id '${templateId}' in template collection.`)
+    }
+    collection[templateId] = template
+  }
+
+  return metadata === undefined
+    ? { [TEMPLATE_COLLECTION_KEY]: collection }
+    : { [TEMPLATE_COLLECTION_KEY]: collection, metadata }
+}
+
+export function extractTemplateCollection(value: unknown): TemplateCollection {
+  if (isEnvelope<unknown>(value)) {
+    assertGenericTemplateEnvelope(value)
+    return { [value.template_id]: value }
+  }
+  if (!isRecord(value)) {
+    throw new Error('Template collection payload must be an object.')
+  }
+
+  const rawCollection = value[TEMPLATE_COLLECTION_KEY]
+  if (rawCollection === undefined) {
+    return {}
+  }
+  if (!isRecord(rawCollection)) {
+    throw new Error('Template collection must be an object.')
+  }
+
+  const collection: TemplateCollection = {}
+  for (const [templateId, template] of Object.entries(rawCollection)) {
+    assertGenericTemplateEnvelope(template)
+    if (template.template_id !== templateId) {
+      throw new Error(
+        `Template collection key '${templateId}' does not match envelope template_id '${template.template_id}'.`
+      )
+    }
+    collection[templateId] = template
+  }
+  return collection
+}
+
+export function ensureTemplateFromCollection<TTemplate extends BioTemplateEnvelope<unknown>>(
+  value: unknown,
+  templateId: TemplateId | string
+): TTemplate {
+  const collection = extractTemplateCollection(value)
+  const template = collection[templateId]
+  if (!template) {
+    throw new Error(`Template '${templateId}' was not found in template collection.`)
+  }
+  assertTemplateEnvelope(template, templateId)
+  return template as TTemplate
+}
+
+export function assertTemplateEnvelope<TData>(
+  value: unknown,
+  templateId: TemplateId | string
+): asserts value is BioTemplateEnvelope<TData> {
+  assertGenericTemplateEnvelope(value)
+  if (value.template_id !== templateId) {
+    throw new Error(`Expected template_id '${templateId}', got '${String(value.template_id)}'.`)
+  }
+}
+
+export function ensureTemplateEnvelope<TTemplate extends BioTemplateEnvelope<unknown>>(
+  value: unknown,
+  templateId: TemplateId | string
+): TTemplate {
+  assertTemplateEnvelope(value, templateId)
+  return value as TTemplate
+}
+
+export function getTemplateData<TData>(
+  template: BioTemplateEnvelope<TData> | TData,
+  templateId?: TemplateId | string
+): TData {
+  if (isEnvelope<TData>(template)) {
+    if (templateId) assertTemplateEnvelope<TData>(template, templateId)
+    return template.data
+  }
+  return template
+}
+
+function assertGenericTemplateEnvelope(value: unknown): asserts value is BioTemplateEnvelope<unknown> {
+  if (!isRecord(value)) {
+    throw new Error('Template envelope must be an object.')
+  }
+  if (typeof value.template_id !== 'string' || value.template_id.length === 0) {
+    throw new Error('Template envelope requires a template_id string.')
+  }
+  if (typeof value.template_version !== 'string' || value.template_version.length === 0) {
+    throw new Error('Template envelope requires a template_version string.')
+  }
+  if (!isRecord(value.data)) {
+    throw new Error('Template envelope data must be an object.')
+  }
+  if ('metadata' in value && !isRecord(value.metadata)) {
+    throw new Error('Template envelope metadata must be an object.')
+  }
+}
+
+function isEnvelope<TData>(value: unknown): value is BioTemplateEnvelope<TData> {
+  return isRecord(value) && 'template_id' in value && 'data' in value
+}

package/src/templates/templatePackCollectionBuilder.ts

@@ -0,0 +1,23 @@
+import { getBioTemplatePackInfo } from './packs'
+import { createDefaultBioTemplate } from './defaultBioTemplateBuilder'
+import { createTemplateCollection } from './templateEnvelopes'
+import type {
+  CreateBioTemplatePackCollectionOptions,
+  TemplateCollectionEnvelope,
+  TemplatePackId,
+} from './types'
+
+export function createBioTemplatePackCollection(
+  name: TemplatePackId | string,
+  options: CreateBioTemplatePackCollectionOptions = {},
+): TemplateCollectionEnvelope {
+  const pack = getBioTemplatePackInfo(name)
+  if (!pack) {
+    throw new Error(`Unknown template pack '${name}'.`)
+  }
+
+  return createTemplateCollection(
+    pack.templates.map(templateId => createDefaultBioTemplate(templateId)),
+    { pack: pack.name, ...(options.metadata ?? {}) },
+  )
+}

package/src/templates/templatePresetCollectionBuilder.ts

@@ -0,0 +1,139 @@
+import { bioTemplatePresetControlValuesToOptions } from './builderPresetControls'
+import type { BioTemplateControlValues } from './builderPresetControls'
+import { createElisaAssayCollection } from './elisaAssayCollectionBuilder'
+import { createFlowCytometryAssayCollection } from './flowCytometryAssayCollectionBuilder'
+import { createLcmsBatchCollection } from './lcmsBatchCollectionBuilder'
+import { getBioTemplatePresetInfo } from './presets'
+import { createQpcrExpressionCollection } from './qpcrExpressionCollectionBuilder'
+import { createTargetedMetabolomicsCollection } from './targetedMetabolomicsCollectionBuilder'
+import { createWellPlateScreenCollection } from './wellPlateScreenCollectionBuilder'
+import { createWesternBlotAssayCollection } from './westernBlotAssayCollectionBuilder'
+import type {
+  CreateElisaAssayCollectionOptions,
+  CreateFlowCytometryAssayCollectionOptions,
+  CreateLcmsBatchCollectionOptions,
+  CreateQpcrExpressionCollectionOptions,
+  CreateTargetedMetabolomicsCollectionOptions,
+  CreateWellPlateScreenCollectionOptions,
+  CreateWesternBlotAssayCollectionOptions,
+  TemplateCollectionEnvelope,
+  TemplatePresetId,
+} from './types'
+
+export function createBioTemplatePresetCollection(
+  name: 'wellplate-screen',
+  options?: CreateWellPlateScreenCollectionOptions
+): TemplateCollectionEnvelope
+export function createBioTemplatePresetCollection(
+  name: 'qpcr-expression',
+  options?: CreateQpcrExpressionCollectionOptions
+): TemplateCollectionEnvelope
+export function createBioTemplatePresetCollection(
+  name: 'lcms-batch',
+  options?: CreateLcmsBatchCollectionOptions
+): TemplateCollectionEnvelope
+export function createBioTemplatePresetCollection(
+  name: 'targeted-metabolomics',
+  options?: CreateTargetedMetabolomicsCollectionOptions
+): TemplateCollectionEnvelope
+export function createBioTemplatePresetCollection(
+  name: 'elisa-assay',
+  options?: CreateElisaAssayCollectionOptions
+): TemplateCollectionEnvelope
+export function createBioTemplatePresetCollection(
+  name: 'flow-cytometry-assay',
+  options?: CreateFlowCytometryAssayCollectionOptions
+): TemplateCollectionEnvelope
+export function createBioTemplatePresetCollection(
+  name: 'western-blot-assay',
+  options?: CreateWesternBlotAssayCollectionOptions
+): TemplateCollectionEnvelope
+export function createBioTemplatePresetCollection(
+  name: string,
+  options?:
+    | CreateWellPlateScreenCollectionOptions
+    | CreateQpcrExpressionCollectionOptions
+    | CreateLcmsBatchCollectionOptions
+    | CreateTargetedMetabolomicsCollectionOptions
+    | CreateElisaAssayCollectionOptions
+    | CreateFlowCytometryAssayCollectionOptions
+    | CreateWesternBlotAssayCollectionOptions
+): TemplateCollectionEnvelope
+export function createBioTemplatePresetCollection(
+  name: TemplatePresetId | string,
+  options:
+    | CreateWellPlateScreenCollectionOptions
+    | CreateQpcrExpressionCollectionOptions
+    | CreateLcmsBatchCollectionOptions
+    | CreateTargetedMetabolomicsCollectionOptions
+    | CreateElisaAssayCollectionOptions
+    | CreateFlowCytometryAssayCollectionOptions
+    | CreateWesternBlotAssayCollectionOptions = {}
+): TemplateCollectionEnvelope {
+  const preset = getBioTemplatePresetInfo(name)
+  if (!preset) {
+    throw new Error(`Unknown template preset '${name}'.`)
+  }
+  if (preset.name === 'wellplate-screen') {
+    return createWellPlateScreenCollection(options as CreateWellPlateScreenCollectionOptions)
+  }
+  if (preset.name === 'qpcr-expression') {
+    return createQpcrExpressionCollection(options as CreateQpcrExpressionCollectionOptions)
+  }
+  if (preset.name === 'lcms-batch') {
+    return createLcmsBatchCollection(options as CreateLcmsBatchCollectionOptions)
+  }
+  if (preset.name === 'targeted-metabolomics') {
+    return createTargetedMetabolomicsCollection(options as CreateTargetedMetabolomicsCollectionOptions)
+  }
+  if (preset.name === 'elisa-assay') {
+    return createElisaAssayCollection(options as CreateElisaAssayCollectionOptions)
+  }
+  if (preset.name === 'flow-cytometry-assay') {
+    return createFlowCytometryAssayCollection(options as CreateFlowCytometryAssayCollectionOptions)
+  }
+  if (preset.name === 'western-blot-assay') {
+    return createWesternBlotAssayCollection(options as CreateWesternBlotAssayCollectionOptions)
+  }
+  throw new Error(`Unknown template preset '${name}'.`)
+}
+
+export function createBioTemplatePresetCollectionFromControls(
+  name: 'wellplate-screen',
+  values: BioTemplateControlValues
+): TemplateCollectionEnvelope
+export function createBioTemplatePresetCollectionFromControls(
+  name: 'qpcr-expression',
+  values: BioTemplateControlValues
+): TemplateCollectionEnvelope
+export function createBioTemplatePresetCollectionFromControls(
+  name: 'lcms-batch',
+  values: BioTemplateControlValues
+): TemplateCollectionEnvelope
+export function createBioTemplatePresetCollectionFromControls(
+  name: 'targeted-metabolomics',
+  values: BioTemplateControlValues
+): TemplateCollectionEnvelope
+export function createBioTemplatePresetCollectionFromControls(
+  name: 'elisa-assay',
+  values: BioTemplateControlValues
+): TemplateCollectionEnvelope
+export function createBioTemplatePresetCollectionFromControls(
+  name: 'flow-cytometry-assay',
+  values: BioTemplateControlValues
+): TemplateCollectionEnvelope
+export function createBioTemplatePresetCollectionFromControls(
+  name: 'western-blot-assay',
+  values: BioTemplateControlValues
+): TemplateCollectionEnvelope
+export function createBioTemplatePresetCollectionFromControls(
+  name: TemplatePresetId | string,
+  values: BioTemplateControlValues
+): TemplateCollectionEnvelope
+export function createBioTemplatePresetCollectionFromControls(
+  name: TemplatePresetId | string,
+  values: BioTemplateControlValues
+): TemplateCollectionEnvelope {
+  const options = bioTemplatePresetControlValuesToOptions(name, values)
+  return createBioTemplatePresetCollection(name, options)
+}

package/src/templates/templateQpcrTypes.ts

@@ -0,0 +1,48 @@
+import type { WellPlateFormat } from '../types'
+import type { BioTemplateEnvelope } from './types'
+
+export type QpcrChemistry = 'sybr' | 'taqman' | 'probe' | 'evagreen' | 'other'
+export type QpcrControlKind = 'sample' | 'no-template' | 'no-rt' | 'positive' | 'standard' | 'calibrator'
+
+export interface QpcrSample {
+  sampleId: string
+  name?: string
+  group?: string
+  metadata?: Record<string, unknown>
+}
+
+export interface QpcrTarget {
+  id: string
+  name: string
+  assayId?: string
+  reporter?: string
+  quencher?: string
+  ampliconBp?: number
+  metadata?: Record<string, unknown>
+}
+
+export interface QpcrReaction {
+  id: string
+  wellId: string
+  sampleId?: string
+  targetId: string
+  replicate: number
+  controlKind: QpcrControlKind
+  cq?: number | null
+  quantity?: number | null
+  flags: string[]
+  metadata?: Record<string, unknown>
+}
+
+export interface QpcrPlateTemplateData {
+  plateId: string
+  format: WellPlateFormat
+  samples: QpcrSample[]
+  targets: QpcrTarget[]
+  reactions: QpcrReaction[]
+  instrument?: string
+  chemistry: QpcrChemistry
+  metadata: Record<string, unknown>
+}
+
+export type QpcrPlateTemplate = BioTemplateEnvelope<QpcrPlateTemplateData>