benchling_typescript_sdk/src/benchlingClient/v2Modules/Schemas.ts

Typescript SDK for Benchling API

import { BaseClient } from "../BaseClient";
import type {
  PlateSchema,
  BoxSchema,
  ContainerSchema,
  AssayResultSchema,
  EntitySchema,
  LocationSchemasGetParamQuery,
  AssayResultSchemasGetParamQuery,
  PlateSchemasGetParamQuery,
  BoxSchemasGetParamQuery,
  ContainerSchemasGetParamQuery,
  EntitySchemasGetParamQuery,
  AssayRunSchemasGetParamQuery,
  AssayRun,
  LocationSchema
} from "../types";

export class Schemas {
  private client: BaseClient;
  constructor(client: BaseClient) {
    this.client = client;
  }

  public getEntitySchema(schema_id: string): Promise<EntitySchema> {
    return this.client.fetchData<EntitySchema>(`entity-schemas/${schema_id}`, {});
  }
  public getPlateSchema(schema_id: string): Promise<PlateSchema> {
    return this.client.fetchData<PlateSchema>(`plate-schemas/${schema_id}`, {});
  }
  public getBoxSchema(schema_id: string): Promise<BoxSchema> {
    return this.client.fetchData<BoxSchema>(`box-schemas/${schema_id}`, {});
  }
  public getContainerSchema(schema_id: string): Promise<ContainerSchema> {
    return this.client.fetchData<ContainerSchema>(`container-schemas/${schema_id}`, {});
  }
  public getAssayResultSchema(schema_id: string): Promise<AssayResultSchema> {
    return this.client.fetchData<AssayResultSchema>(`assay-result-schemas/${schema_id}`, {});
  }
  public getAssayRunSchema(schema_id: string): Promise<AssayRun> {
    return this.client.fetchData<AssayRun>(`assay-run-schemas/${schema_id}`, {});
  }
  public getLocationSchema(schema_id: string): Promise<LocationSchema> {
    return this.client.fetchData<LocationSchema>(`location-schemas/${schema_id}`, {});
  }

  public listPlateSchemas(parameters: PlateSchemasGetParamQuery): AsyncGenerator<PlateSchema[]> {
    return this.client.fetchPagesIterator<PlateSchema>("plate-schemas", parameters);
  }

  public listBoxSchemas(parameters: BoxSchemasGetParamQuery): AsyncGenerator<BoxSchema[]> {
    return this.client.fetchPagesIterator<BoxSchema>("box-schemas", parameters);
  }

  public listAssayRunSchemas(parameters: AssayRunSchemasGetParamQuery): AsyncGenerator<AssayRun[]> {
    return this.client.fetchPagesIterator<AssayRun>("assay-run-schemas", parameters);
  }

  public listContainerSchemas(
    parameters: ContainerSchemasGetParamQuery
  ): AsyncGenerator<ContainerSchema[]> {
    return this.client.fetchPagesIterator<ContainerSchema>("container-schemas", parameters);
  }

  public listAssayResultSchemas(
    parameters: AssayResultSchemasGetParamQuery
  ): AsyncGenerator<AssayResultSchema[]> {
    return this.client.fetchPagesIterator<AssayResultSchema>("assay-result-schemas", parameters);
  }

  public listLocationSchemas(
    parameters: LocationSchemasGetParamQuery
  ): AsyncGenerator<LocationSchema[]> {
    return this.client.fetchPagesIterator<LocationSchema>("location-schemas", parameters);
  }
  public listEntitySchemas(parameters: EntitySchemasGetParamQuery): AsyncGenerator<EntitySchema[]> {
    return this.client.fetchPagesIterator<EntitySchema>("entity-schemas", parameters);
  }

  public async listContainableEntitySchemas(): Promise<EntitySchema[]> {
    const endpoint = "entity-schemas";
    const pagesIterator = this.client.fetchPagesIterator<EntitySchema>(endpoint, {
      pageSize: 50,
    });
    // iterate over pagesIterator and return the prefixes
    const containableSchemas = [] as EntitySchema[];
    let pages = 0;
    let schemas = 0;
    for await (const page of pagesIterator) {
      pages++;
      // console.log("page # ", pages);
      for (const entitySchema of page) {
        schemas++;
        // console.log("entitySchema # ", schemas);
        // console.log(entitySchema.prefix);

        if (entitySchema.containableType === "ENTITY") {
          if (!entitySchema.prefix || !entitySchema.id || !entitySchema.name) {
            throw new Error(
              `Internal Program Error: getContainableEntityPrefixes(): Entity without prefix, id, or name found in get entity-schemas response`
            );
          }
          containableSchemas.push(entitySchema);
        }
      }
    }

    return containableSchemas;
  }
}