synapse-react-client 4.0.20 → 4.0.21

package/dist/components/TableColumnSchemaEditor/Validators/ColumnModelValidator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ColumnModelValidator.d.ts","sourceRoot":"","sources":["../../../../src/components/TableColumnSchemaEditor/Validators/ColumnModelValidator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAA;AAO7E,OAAO,EAAE,KAAK,mBAAmB,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAkBvC,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;EAKvC,CAAA;AAqCD;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8D7B,CAAA;AAEJ,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAAgC,CAAA;AAEzE,QAAA,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;EAIrC,CAAA;AAED,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,gCAAgC,CACxC,CAAA;AAGD,QAAA,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM/B,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAE5E,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,WAAW,CACnB,mBAAmB,EACnB,2BAA2B,GAAG,YAAY,CAC3C,EAAE,GACF,mBAAmB,CACpB,WAAW,CACT,mBAAmB,EACnB,2BAA2B,GAAG,YAAY,CAC3C,EAAE,EACH,WAAW,CAAC,WAAW,EAAE,IAAI,CAAC,EAAE,CACjC,CAEA"}
+{"version":3,"file":"ColumnModelValidator.d.ts","sourceRoot":"","sources":["../../../../src/components/TableColumnSchemaEditor/Validators/ColumnModelValidator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAA;AAU7E,OAAO,EAAE,CAAC,EAAW,MAAM,KAAK,CAAA;AAChC,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAuBvC,eAAO,MAAM,2BAA2B;;;;;;;;iBAGtC,CAAA;AAyDF;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2F7B,CAAA;AAEJ,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAgC,CAAA;AAEzE,QAAA,MAAM,gCAAgC;;;;;;;;;iBAEpC,CAAA;AAEF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,gCAAgC,CACxC,CAAA;AAGD,QAAA,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAI9B,CAAA;AAEF;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAE5E,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,WAAW,CACnB,mBAAmB,EACnB,2BAA2B,GAAG,YAAY,CAC3C,EAAE,GACF,CAAC,CAAC,kBAAkB,CAAC,WAAW,CAAC,WAAW,EAAE,IAAI,CAAC,EAAE,CAAC,CAExD"}

package/dist/components/TableColumnSchemaEditor/Validators/ColumnModelValidator.js

@@ -1,76 +1,76 @@
-import { MAX_STRING_SIZE as e, canHaveMaxListLength as t, canHaveSize as n } from "../TableColumnSchemaEditorUtils.js";
-import { getDefaultValueValidator as r } from "./DefaultValueValidator.js";
-import i from "./EnumValuesValidator.js";
-import { optionalStringSchema as a } from "./OptionalStringSchema.js";
-import { omit as o } from "lodash-es";
-import { ColumnTypeEnum as s } from "@sage-bionetworks/synapse-types";
-import { z as c } from "zod";
+import { DISALLOWED_DEFAULT_VALUE_COLUMN_TYPES as e, MAX_STRING_SIZE as t, canHaveMaxListLength as n, canHaveSize as r, getMaxListLengthForType as i } from "../TableColumnSchemaEditorUtils.js";
+import { getDefaultValueValidator as a } from "./DefaultValueValidator.js";
+import o from "./EnumValuesValidator.js";
+import { optionalStringSchema as s } from "./OptionalStringSchema.js";
+import { omit as c } from "lodash-es";
+import { ColumnTypeEnum as l } from "@sage-bionetworks/synapse-types";
+import { z as u } from "zod";
 //#region src/components/TableColumnSchemaEditor/Validators/ColumnModelValidator.ts
-var l = c.union([c.literal("enumeration"), c.literal("range")]), u = c.object({
-	property: c.enum(["FREQUENCY", "VALUE"]).optional(),
-	direction: c.enum(["DESC", "ASC"]).optional()
-}), d = c.object({
-	name: c.string().min(1, { message: "Name is required" }),
-	columnType: c.nativeEnum(s)
-}), f = d.merge(c.object({
-	jsonPath: c.string().startsWith("$"),
-	facetType: l
-})), p = d.merge(c.object({
-	id: c.string().optional(),
-	defaultValue: c.union([c.string(), c.array(c.any())]).optional(),
-	maximumSize: c.union([a, c.number()]).pipe(c.coerce.number().finite().int().min(1).max(e).optional()),
-	maximumListLength: c.union([a, c.number()]).pipe(c.coerce.number().finite().int().min(1).max(100).optional()),
-	enumValues: c.array(c.union([c.string(), c.number().int()]).pipe(c.coerce.string())).optional(),
-	jsonSubColumns: c.array(f).optional(),
-	facetType: l.optional(),
-	facetSortConfig: u.optional()
-})), m = p.refine((e) => e.maximumSize == null || n(e.columnType), {
+var d = u.enum(["enumeration", "range"]), f = u.object({
+	property: u.enum(["FREQUENCY", "VALUE"]).optional(),
+	direction: u.enum(["DESC", "ASC"]).optional()
+}), p = u.object({
+	name: u.string().min(1, { message: "Name is required" }).max(256, { message: "Name must be 256 characters or fewer" }),
+	columnType: u.enum(l)
+}), m = p.extend({
+	jsonPath: u.string().startsWith("$"),
+	facetType: d
+}), h = p.extend({
+	id: u.string().optional(),
+	defaultValue: u.union([u.string(), u.array(u.any())]).optional(),
+	maximumSize: u.union([s, u.number()]).transform((e) => typeof e == "string" ? Number(e) : e).pipe(u.number().int().min(1).max(t).optional()),
+	maximumListLength: u.union([s, u.number()]).transform((e) => typeof e == "string" ? Number(e) : e).pipe(u.number().int().min(1).optional()),
+	enumValues: u.array(u.union([u.string(), u.number().int()]).pipe(u.coerce.string())).max(100, { message: "A column may have at most 100 enumeration values" }).optional(),
+	jsonSubColumns: u.array(m).optional(),
+	facetType: d.optional(),
+	facetSortConfig: f.optional()
+});
+function g(e, t, n, r) {
+	let i = t.safeParse(e);
+	if (i.success) return i.data;
+	i.error.issues.forEach((e) => {
+		r.addIssue({
+			...e,
+			path: [n]
+		});
+	});
+}
+var _ = h.refine((e) => e.maximumSize == null || r(e.columnType), {
 	message: "Size is not allowed for this column type",
 	path: ["maximumSize"]
-}).refine((e) => e.maximumListLength == null || t(e.columnType), {
+}).refine((e) => e.maximumListLength == null || n(e.columnType), {
 	message: "Maximum list length is not allowed for this column type",
 	path: ["maximumListLength"]
-}).refine((e) => e.jsonSubColumns == null ? !0 : e.columnType === s.JSON, {
+}).superRefine((e, t) => {
+	if (e.maximumListLength == null || !n(e.columnType)) return;
+	let r = i(e.columnType, e.maximumSize);
+	e.maximumListLength > r && t.addIssue({
+		code: "custom",
+		message: `Maximum list length must not exceed ${r} for this column type and element size`,
+		path: ["maximumListLength"]
+	});
+}).refine((e) => e.jsonSubColumns == null ? !0 : e.columnType === l.JSON, {
 	message: "Only JSON columns can have JSON sub-columns.",
 	path: ["columnType"]
-}).transform((e, t) => {
-	if (e.defaultValue != null) {
-		let n = r(e.columnType).safeParse(e.defaultValue), i;
-		return n.success ? i = n.data : (n.error.issues.forEach((e) => {
-			t.addIssue({
-				...e,
-				path: ["defaultValue"]
-			});
-		}), i = void 0), {
-			...e,
-			defaultValue: i
-		};
-	}
-	return o(e, "defaultValue");
-}).transform((e, t) => {
-	if (e.enumValues != null) {
-		let n = i(e.columnType).safeParse(e.enumValues), r;
-		return n.success ? r = n.data : (n.error.issues.forEach((e) => {
-			t.addIssue({
-				...e,
-				path: ["enumValues"]
-			});
-		}), r = void 0), {
-			...e,
-			enumValues: r
-		};
-	}
-	return o(e, "enumValues");
-}), h = c.array(m), g = f.merge(c.object({ isSelected: c.boolean() }));
-p.merge(c.object({
-	isSelected: c.boolean(),
-	isOriginallyDefaultColumn: c.boolean(),
-	jsonSubColumns: c.array(g).optional()
-}));
-function _(e) {
-	return h.safeParse(e);
+}).refine((t) => !(t.defaultValue != null && t.defaultValue !== "" && !(Array.isArray(t.defaultValue) && t.defaultValue.length === 0)) || !e.includes(t.columnType), {
+	message: "A default value is not allowed for this column type",
+	path: ["defaultValue"]
+}).transform((e, t) => e.defaultValue == null ? c(e, "defaultValue") : {
+	...e,
+	defaultValue: g(e.defaultValue, a(e.columnType), "defaultValue", t)
+}).transform((e, t) => e.enumValues == null ? c(e, "enumValues") : {
+	...e,
+	enumValues: g(e.enumValues, o(e.columnType), "enumValues", t)
+}), v = u.array(_), y = m.extend({ isSelected: u.boolean() });
+h.extend({
+	isSelected: u.boolean(),
+	isOriginallyDefaultColumn: u.boolean(),
+	jsonSubColumns: u.array(y).optional()
+});
+function b(e) {
+	return v.safeParse(e);
 }
 //#endregion
-export { h as columnModelFormDataZodSchema, m as columnModelZodSchema, f as jsonSubColumnModelZodSchema, _ as validateColumnModelFormData };
+export { v as columnModelFormDataZodSchema, _ as columnModelZodSchema, m as jsonSubColumnModelZodSchema, b as validateColumnModelFormData };
 
 //# sourceMappingURL=ColumnModelValidator.js.map

package/dist/components/TableColumnSchemaEditor/Validators/ColumnModelValidator.js.map

@@ -1 +1 @@
-{"version":3,"file":"ColumnModelValidator.js","names":[],"sources":["../../../../src/components/TableColumnSchemaEditor/Validators/ColumnModelValidator.ts"],"sourcesContent":["import { ColumnModel, ColumnTypeEnum } from '@sage-bionetworks/synapse-types'\nimport {\n  canHaveMaxListLength,\n  canHaveSize,\n  MAX_LIST_LENGTH,\n  MAX_STRING_SIZE,\n} from '../TableColumnSchemaEditorUtils'\nimport { type SafeParseReturnType, z } from 'zod'\nimport { SetOptional } from 'type-fest'\nimport { getDefaultValueValidator } from './DefaultValueValidator'\nimport getEnumValuesValidator from './EnumValuesValidator'\nimport { optionalStringSchema } from './OptionalStringSchema'\nimport { omit } from 'lodash-es'\n\nconst facetTypeSchema = z.union([z.literal('enumeration'), z.literal('range')])\n\nconst facetColumnSortConfigSchema = z.object({\n  property: z.enum(['FREQUENCY', 'VALUE']).optional(),\n  direction: z.enum(['DESC', 'ASC']).optional(),\n})\n\nconst columnModelBaseZodSchema = z.object({\n  name: z.string().min(1, { message: 'Name is required' }),\n  columnType: z.nativeEnum(ColumnTypeEnum),\n})\n\nexport const jsonSubColumnModelZodSchema = columnModelBaseZodSchema.merge(\n  z.object({\n    jsonPath: z.string().startsWith('$'),\n    facetType: facetTypeSchema,\n  }),\n)\n\n/**\n * Zod schema whose shape represents a ColumnModel. This unrefined schema is saved in this \"intermediate\" state so\n * that it can be extended with `.merge` to create an inferred type that can applied to form data.\n */\nconst unrefinedColumnModelSchema = columnModelBaseZodSchema.merge(\n  z.object({\n    id: z.string().optional(),\n    defaultValue: z.union([z.string(), z.array(z.any())]).optional(),\n    maximumSize: z\n      .union([optionalStringSchema, z.number()])\n      .pipe(\n        z.coerce.number().finite().int().min(1).max(MAX_STRING_SIZE).optional(),\n      ),\n    maximumListLength: z\n      .union([optionalStringSchema, z.number()])\n      .pipe(\n        z.coerce.number().finite().int().min(1).max(MAX_LIST_LENGTH).optional(),\n      ),\n    enumValues: z\n      .array(\n        z\n          .union([\n            z.string(),\n            // enumValues is allowed on INTEGER type, but the backend stores them as strings, so allow passing integers\n            z.number().int(),\n          ])\n          .pipe(z.coerce.string()),\n      )\n      .optional(),\n    jsonSubColumns: z.array(jsonSubColumnModelZodSchema).optional(),\n    facetType: facetTypeSchema.optional(),\n    facetSortConfig: facetColumnSortConfigSchema.optional(),\n  }),\n)\n\n/**\n * Zod schema to validate a column model. The provided data is coerced and transformed to match the ColumnModel type.\n * For this reason, form data may be directly passed into this schema parser.\n *\n * The parse method will return a ColumnModel where all data is properly formed.\n */\nexport const columnModelZodSchema = unrefinedColumnModelSchema\n  .refine(data => data.maximumSize == null || canHaveSize(data.columnType), {\n    message: 'Size is not allowed for this column type',\n    path: ['maximumSize'],\n  })\n  .refine(\n    data =>\n      data.maximumListLength == null || canHaveMaxListLength(data.columnType),\n    {\n      message: 'Maximum list length is not allowed for this column type',\n      path: ['maximumListLength'],\n    },\n  )\n  .refine(\n    data => {\n      if (data.jsonSubColumns != null) {\n        return data.columnType === ColumnTypeEnum.JSON\n      }\n      return true\n    },\n    {\n      message: 'Only JSON columns can have JSON sub-columns.',\n      path: ['columnType'],\n    },\n  )\n  .transform((data, ctx) => {\n    if (data.defaultValue != null) {\n      // Validate and transform the defaultValue based on the columnType\n      const defaultValueSchema = getDefaultValueValidator(data.columnType)\n      const result = defaultValueSchema.safeParse(data.defaultValue)\n      let transformedValue: string | undefined\n      if (result.success) {\n        transformedValue = result.data\n      } else {\n        result.error.issues.forEach(issue => {\n          ctx.addIssue({ ...issue, path: ['defaultValue'] })\n        })\n        transformedValue = undefined\n      }\n      return { ...data, defaultValue: transformedValue }\n    }\n    return omit(data, 'defaultValue')\n  })\n  .transform((data, ctx) => {\n    // NOTE: This is the same set of steps as the `defaultValue` transform\n    // We may be able to refactor this, but it is challenging to do so without breaking the schema's inferred type\n    if (data.enumValues != null) {\n      // Validate and transform the defaultValue based on the columnType\n      const enumValuesSchema = getEnumValuesValidator(data.columnType)\n      const result = enumValuesSchema.safeParse(data.enumValues)\n      let transformedValue: string[] | undefined\n      if (result.success) {\n        transformedValue = result.data\n      } else {\n        result.error.issues.forEach(issue => {\n          ctx.addIssue({ ...issue, path: ['enumValues'] })\n        })\n        transformedValue = undefined\n      }\n      return { ...data, enumValues: transformedValue }\n    }\n    return omit(data, 'enumValues')\n  })\n\nexport const columnModelFormDataZodSchema = z.array(columnModelZodSchema)\n\nconst jsonSubColumnModelFormDataSchema = jsonSubColumnModelZodSchema.merge(\n  z.object({\n    isSelected: z.boolean(),\n  }),\n)\n\nexport type JsonSubColumnModelFormData = z.input<\n  typeof jsonSubColumnModelFormDataSchema\n>\n\n// Use the \"unrefined\" schema since we can extend it with form-only fields\nconst _columnModelFormDataSchema = unrefinedColumnModelSchema.merge(\n  z.object({\n    isSelected: z.boolean(),\n    isOriginallyDefaultColumn: z.boolean(),\n    jsonSubColumns: z.array(jsonSubColumnModelFormDataSchema).optional(),\n  }),\n)\n\n/**\n * Type that represents possible form input data for a ColumnModel.\n * a\n */\nexport type ColumnModelFormData = z.input<typeof _columnModelFormDataSchema>\n\nexport function validateColumnModelFormData(\n  formData: SetOptional<\n    ColumnModelFormData,\n    'isOriginallyDefaultColumn' | 'isSelected'\n  >[],\n): SafeParseReturnType<\n  SetOptional<\n    ColumnModelFormData,\n    'isOriginallyDefaultColumn' | 'isSelected'\n  >[],\n  SetOptional<ColumnModel, 'id'>[]\n> {\n  return columnModelFormDataZodSchema.safeParse(formData)\n}\n"],"mappings":"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"}
+{"version":3,"file":"ColumnModelValidator.js","names":[],"sources":["../../../../src/components/TableColumnSchemaEditor/Validators/ColumnModelValidator.ts"],"sourcesContent":["import { ColumnModel, ColumnTypeEnum } from '@sage-bionetworks/synapse-types'\nimport {\n  canHaveMaxListLength,\n  canHaveSize,\n  DISALLOWED_DEFAULT_VALUE_COLUMN_TYPES,\n  getMaxListLengthForType,\n  MAX_COLUMN_NAME_LENGTH,\n  MAX_ENUM_VALUES,\n  MAX_STRING_SIZE,\n} from '../TableColumnSchemaEditorUtils'\nimport { z, ZodType } from 'zod'\nimport { SetOptional } from 'type-fest'\nimport { getDefaultValueValidator } from './DefaultValueValidator'\nimport getEnumValuesValidator from './EnumValuesValidator'\nimport { optionalStringSchema } from './OptionalStringSchema'\nimport { omit } from 'lodash-es'\n\nconst facetTypeSchema = z.enum(['enumeration', 'range'])\n\nconst facetColumnSortConfigSchema = z.object({\n  property: z.enum(['FREQUENCY', 'VALUE']).optional(),\n  direction: z.enum(['DESC', 'ASC']).optional(),\n})\n\nconst columnModelBaseZodSchema = z.object({\n  name: z\n    .string()\n    .min(1, { message: 'Name is required' })\n    .max(MAX_COLUMN_NAME_LENGTH, {\n      message: `Name must be ${MAX_COLUMN_NAME_LENGTH} characters or fewer`,\n    }),\n  columnType: z.enum(ColumnTypeEnum),\n})\n\nexport const jsonSubColumnModelZodSchema = columnModelBaseZodSchema.extend({\n  jsonPath: z.string().startsWith('$'),\n  facetType: facetTypeSchema,\n})\n\n/**\n * Zod schema whose shape represents a ColumnModel. This unrefined schema is saved in this \"intermediate\" state so\n * that it can be extended to create an inferred type that can applied to form data.\n */\nconst unrefinedColumnModelSchema = columnModelBaseZodSchema.extend({\n  id: z.string().optional(),\n  defaultValue: z.union([z.string(), z.array(z.any())]).optional(),\n  maximumSize: z\n    .union([optionalStringSchema, z.number()])\n    // Convert string input to a number before validating\n    .transform(v => (typeof v === 'string' ? Number(v) : v))\n    .pipe(z.number().int().min(1).max(MAX_STRING_SIZE).optional()),\n  maximumListLength: z\n    .union([optionalStringSchema, z.number()])\n    .transform(v => (typeof v === 'string' ? Number(v) : v))\n    .pipe(z.number().int().min(1).optional()),\n  enumValues: z\n    .array(\n      z\n        .union([\n          z.string(),\n          // enumValues is allowed on INTEGER type, but the backend stores them as strings, so allow passing integers\n          z.number().int(),\n        ])\n        .pipe(z.coerce.string()),\n    )\n    .max(MAX_ENUM_VALUES, {\n      message: `A column may have at most ${MAX_ENUM_VALUES} enumeration values`,\n    })\n    .optional(),\n  jsonSubColumns: z.array(jsonSubColumnModelZodSchema).optional(),\n  facetType: facetTypeSchema.optional(),\n  facetSortConfig: facetColumnSortConfigSchema.optional(),\n})\n\n/**\n * Runs a field-specific sub-validator against a value, forwarding any issues to the parent\n * context (re-pathed to `path`). Returns the transformed value, or undefined if validation failed.\n */\nfunction parseSubField<T>(\n  value: unknown,\n  schema: ZodType<T | undefined>,\n  path: string,\n  ctx: z.RefinementCtx,\n): T | undefined {\n  const result = schema.safeParse(value)\n  if (result.success) {\n    return result.data\n  }\n  result.error.issues.forEach(issue => {\n    ctx.addIssue({ ...issue, path: [path] })\n  })\n  return undefined\n}\n\n/**\n * Zod schema to validate a column model. The provided data is coerced and transformed to match the ColumnModel type.\n * For this reason, form data may be directly passed into this schema parser.\n *\n * The parse method will return a ColumnModel where all data is properly formed.\n */\nexport const columnModelZodSchema = unrefinedColumnModelSchema\n  .refine(data => data.maximumSize == null || canHaveSize(data.columnType), {\n    message: 'Size is not allowed for this column type',\n    path: ['maximumSize'],\n  })\n  .refine(\n    data =>\n      data.maximumListLength == null || canHaveMaxListLength(data.columnType),\n    {\n      message: 'Maximum list length is not allowed for this column type',\n      path: ['maximumListLength'],\n    },\n  )\n  .superRefine((data, ctx) => {\n    if (\n      data.maximumListLength == null ||\n      !canHaveMaxListLength(data.columnType)\n    ) {\n      // Either no list length is set, or a previous refinement already rejected it\n      return\n    }\n    const maxListLength = getMaxListLengthForType(\n      data.columnType,\n      data.maximumSize,\n    )\n    if (data.maximumListLength > maxListLength) {\n      ctx.addIssue({\n        code: 'custom',\n        message: `Maximum list length must not exceed ${maxListLength} for this column type and element size`,\n        path: ['maximumListLength'],\n      })\n    }\n  })\n  .refine(\n    data => {\n      if (data.jsonSubColumns != null) {\n        return data.columnType === ColumnTypeEnum.JSON\n      }\n      return true\n    },\n    {\n      message: 'Only JSON columns can have JSON sub-columns.',\n      path: ['columnType'],\n    },\n  )\n  .refine(\n    data => {\n      // An empty string or empty array is treated as \"no default value\" (see the defaultValue transform below)\n      const hasDefaultValue =\n        data.defaultValue != null &&\n        data.defaultValue !== '' &&\n        !(Array.isArray(data.defaultValue) && data.defaultValue.length === 0)\n      return (\n        !hasDefaultValue ||\n        !DISALLOWED_DEFAULT_VALUE_COLUMN_TYPES.includes(data.columnType)\n      )\n    },\n    {\n      message: 'A default value is not allowed for this column type',\n      path: ['defaultValue'],\n    },\n  )\n  .transform((data, ctx) => {\n    // Validate and transform the defaultValue based on the columnType\n    if (data.defaultValue == null) {\n      return omit(data, 'defaultValue')\n    }\n    return {\n      ...data,\n      defaultValue: parseSubField(\n        data.defaultValue,\n        getDefaultValueValidator(data.columnType),\n        'defaultValue',\n        ctx,\n      ),\n    }\n  })\n  .transform((data, ctx) => {\n    // Validate and transform the enumValues based on the columnType\n    if (data.enumValues == null) {\n      return omit(data, 'enumValues')\n    }\n    return {\n      ...data,\n      enumValues: parseSubField(\n        data.enumValues,\n        getEnumValuesValidator(data.columnType),\n        'enumValues',\n        ctx,\n      ),\n    }\n  })\n\nexport const columnModelFormDataZodSchema = z.array(columnModelZodSchema)\n\nconst jsonSubColumnModelFormDataSchema = jsonSubColumnModelZodSchema.extend({\n  isSelected: z.boolean(),\n})\n\nexport type JsonSubColumnModelFormData = z.input<\n  typeof jsonSubColumnModelFormDataSchema\n>\n\n// Use the \"unrefined\" schema since we can extend it with form-only fields\nconst _columnModelFormDataSchema = unrefinedColumnModelSchema.extend({\n  isSelected: z.boolean(),\n  isOriginallyDefaultColumn: z.boolean(),\n  jsonSubColumns: z.array(jsonSubColumnModelFormDataSchema).optional(),\n})\n\n/**\n * Type that represents possible form input data for a ColumnModel.\n * a\n */\nexport type ColumnModelFormData = z.input<typeof _columnModelFormDataSchema>\n\nexport function validateColumnModelFormData(\n  formData: SetOptional<\n    ColumnModelFormData,\n    'isOriginallyDefaultColumn' | 'isSelected'\n  >[],\n): z.ZodSafeParseResult<SetOptional<ColumnModel, 'id'>[]> {\n  return columnModelFormDataZodSchema.safeParse(formData)\n}\n"],"mappings":"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"}

package/dist/components/TableColumnSchemaEditor/Validators/DatetimeSchema.d.ts

@@ -2,5 +2,5 @@ import { z } from 'zod';
 /**
  * Validates and converts a value to a valid Synapse DATE value
  */
-export declare const dateTimeSchema: z.ZodEffects<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodString, string, string>, z.ZodDate]>, string, string | number | Date>;
+export declare const dateTimeSchema: z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodDate]>, z.ZodTransform<string, string | number | Date>>;
 //# sourceMappingURL=DatetimeSchema.d.ts.map

package/dist/components/TableColumnSchemaEditor/Validators/DatetimeSchema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DatetimeSchema.d.ts","sourceRoot":"","sources":["../../../../src/components/TableColumnSchemaEditor/Validators/DatetimeSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAgBvB;;GAEG;AACH,eAAO,MAAM,cAAc,+HAEkC,CAAA"}
+{"version":3,"file":"DatetimeSchema.d.ts","sourceRoot":"","sources":["../../../../src/components/TableColumnSchemaEditor/Validators/DatetimeSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAgBvB;;GAEG;AACH,eAAO,MAAM,cAAc,kKAEkC,CAAA"}

package/dist/components/TableColumnSchemaEditor/Validators/DoubleSchema.d.ts

@@ -2,5 +2,5 @@ import { z } from 'zod';
 /**
  * Validates and converts a value to a valid Synapse DOUBLE value. Zod will return an error if the value cannot be converted to a number.
  */
-export declare const doubleSchema: z.ZodEffects<z.ZodUnion<[z.ZodNumber, z.ZodNaN, z.ZodEffects<z.ZodString, string | number, string>]>, string | number, string | number>;
+export declare const doubleSchema: z.ZodPipe<z.ZodUnion<readonly [z.ZodCustom<number, number>, z.ZodPipe<z.ZodString, z.ZodTransform<string | number, string>>]>, z.ZodTransform<string | number, string | number>>;
 //# sourceMappingURL=DoubleSchema.d.ts.map

package/dist/components/TableColumnSchemaEditor/Validators/DoubleSchema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DoubleSchema.d.ts","sourceRoot":"","sources":["../../../../src/components/TableColumnSchemaEditor/Validators/DoubleSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAwBvB;;GAEG;AACH,eAAO,MAAM,YAAY,yIAerB,CAAA"}
+{"version":3,"file":"DoubleSchema.d.ts","sourceRoot":"","sources":["../../../../src/components/TableColumnSchemaEditor/Validators/DoubleSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AA4BvB;;GAEG;AACH,eAAO,MAAM,YAAY,kLAiBrB,CAAA"}

package/dist/components/TableColumnSchemaEditor/Validators/DoubleSchema.js

@@ -1,25 +1,18 @@
 import { z as e } from "zod";
 //#region src/components/TableColumnSchemaEditor/Validators/DoubleSchema.ts
-var t = e.string().transform((t, n) => {
+var t = e.custom((e) => typeof e == "number"), n = e.string().transform((t, n) => {
 	if ([
 		"NaN",
 		"Infinity",
 		"-Infinity"
 	].includes(t)) return t;
 	let r = Number(t);
-	return isNaN(r) && n.addIssue({
-		code: e.ZodIssueCode.invalid_type,
-		expected: "number",
-		received: "string",
-		path: [],
+	return isNaN(r) ? (n.addIssue({
+		code: "custom",
 		message: "Must be a number"
-	}), r;
-}), n = e.union([
-	e.number(),
-	e.nan(),
-	t
-]).transform((e) => typeof e == "number" ? isNaN(e) ? "NaN" : e === Infinity ? "Infinity" : e === -Infinity ? "-Infinity" : e : e);
+	}), e.NEVER) : r;
+}), r = e.union([t, n]).transform((e) => typeof e == "number" ? isNaN(e) ? "NaN" : e === Infinity ? "Infinity" : e === -Infinity ? "-Infinity" : e : e);
 //#endregion
-export { n as doubleSchema };
+export { r as doubleSchema };
 
 //# sourceMappingURL=DoubleSchema.js.map

package/dist/components/TableColumnSchemaEditor/Validators/DoubleSchema.js.map

@@ -1 +1 @@
-{"version":3,"file":"DoubleSchema.js","names":[],"sources":["../../../../src/components/TableColumnSchemaEditor/Validators/DoubleSchema.ts"],"sourcesContent":["import { z } from 'zod'\n\n/**\n * Schema that converts strings to valid Synapse DOUBLE values. Zod will return an error if the string cannot be parsed as a number.\n */\nconst doubleString = z.string().transform((data, ctx) => {\n  // Synapse permits NaN/Infinity, so we can keep these strings\n  if (['NaN', 'Infinity', '-Infinity'].includes(data)) {\n    return data\n  }\n  const parsed = Number(data)\n  // If the parse result is NaN, then this was not a valid number\n  if (isNaN(parsed)) {\n    ctx.addIssue({\n      code: z.ZodIssueCode.invalid_type,\n      expected: 'number',\n      received: 'string',\n      path: [],\n      message: 'Must be a number',\n    })\n  }\n  return parsed\n})\n\n/**\n * Validates and converts a value to a valid Synapse DOUBLE value. Zod will return an error if the value cannot be converted to a number.\n */\nexport const doubleSchema = z\n  .union([z.number(), z.nan(), doubleString])\n  .transform((val): string | number => {\n    if (typeof val === 'number') {\n      // JSON does not support NaN/Infinity, but Synapse does if they are strings\n      if (isNaN(val)) {\n        return 'NaN'\n      } else if (val === Infinity) {\n        return 'Infinity'\n      } else if (val === -Infinity) {\n        return '-Infinity'\n      }\n      return val\n    }\n    return val\n  })\n"],"mappings":";;AAKA,IAAM,IAAe,EAAE,OAAO,EAAE,WAAW,GAAM,MAAQ;CAEvD,IAAI;EAAC;EAAO;EAAY;CAAW,EAAE,SAAS,CAAI,GAChD,OAAO;CAET,IAAM,IAAS,OAAO,CAAI;CAW1B,OATI,MAAM,CAAM,KACd,EAAI,SAAS;EACX,MAAM,EAAE,aAAa;EACrB,UAAU;EACV,UAAU;EACV,MAAM,CAAC;EACP,SAAS;CACX,CAAC,GAEI;AACT,CAAC,GAKY,IAAe,EACzB,MAAM;CAAC,EAAE,OAAO;CAAG,EAAE,IAAI;CAAG;AAAY,CAAC,EACzC,WAAW,MACN,OAAO,KAAQ,WAEb,MAAM,CAAG,IACJ,QACE,MAAQ,WACV,aACE,MAAQ,YACV,cAEF,IAEF,CACR"}
+{"version":3,"file":"DoubleSchema.js","names":[],"sources":["../../../../src/components/TableColumnSchemaEditor/Validators/DoubleSchema.ts"],"sourcesContent":["import { z } from 'zod'\n\n/**\n * Accepts any JavaScript number, including NaN and +/-Infinity. In zod 4, `z.number()`\n * only accepts finite values, but Synapse DOUBLE columns support NaN and +/- Infinity (as strings).\n */\nconst anyNumberSchema = z.custom<number>(val => typeof val === 'number')\n\n/**\n * Schema that converts strings to valid Synapse DOUBLE values. Zod will return an error if the string cannot be parsed as a number.\n */\nconst doubleString = z.string().transform((data, ctx) => {\n  // Synapse permits NaN/Infinity, so we can keep these strings\n  if (['NaN', 'Infinity', '-Infinity'].includes(data)) {\n    return data\n  }\n  const parsed = Number(data)\n  // If the parse result is NaN, then this was not a valid number\n  if (isNaN(parsed)) {\n    ctx.addIssue({\n      code: 'custom',\n      message: 'Must be a number',\n    })\n    return z.NEVER\n  }\n  return parsed\n})\n\n/**\n * Validates and converts a value to a valid Synapse DOUBLE value. Zod will return an error if the value cannot be converted to a number.\n */\nexport const doubleSchema = z\n  .union([anyNumberSchema, doubleString])\n  .transform((val): string | number => {\n    // JSON does not support NaN/Infinity, but Synapse does if they are strings\n    if (typeof val !== 'number') {\n      return val\n    }\n    if (isNaN(val)) {\n      return 'NaN'\n    }\n    if (val === Infinity) {\n      return 'Infinity'\n    }\n    if (val === -Infinity) {\n      return '-Infinity'\n    }\n    return val\n  })\n"],"mappings":";;AAMA,IAAM,IAAkB,EAAE,QAAe,MAAO,OAAO,KAAQ,QAAQ,GAKjE,IAAe,EAAE,OAAO,EAAE,WAAW,GAAM,MAAQ;CAEvD,IAAI;EAAC;EAAO;EAAY;CAAW,EAAE,SAAS,CAAI,GAChD,OAAO;CAET,IAAM,IAAS,OAAO,CAAI;CAS1B,OAPI,MAAM,CAAM,KACd,EAAI,SAAS;EACX,MAAM;EACN,SAAS;CACX,CAAC,GACM,EAAE,SAEJ;AACT,CAAC,GAKY,IAAe,EACzB,MAAM,CAAC,GAAiB,CAAY,CAAC,EACrC,WAAW,MAEN,OAAO,KAAQ,WAGf,MAAM,CAAG,IACJ,QAEL,MAAQ,WACH,aAEL,MAAQ,YACH,cAEF,IAXE,CAYV"}

package/dist/components/TableColumnSchemaEditor/Validators/EntityIdSchema.d.ts

@@ -2,5 +2,5 @@ import { z } from 'zod';
 /**
  * Validates and converts a value to a valid Synapse ENTITYID value
  */
-export declare const entityIdSchema: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+export declare const entityIdSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
 //# sourceMappingURL=EntityIdSchema.d.ts.map

package/dist/components/TableColumnSchemaEditor/Validators/EntityIdSchema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EntityIdSchema.d.ts","sourceRoot":"","sources":["../../../../src/components/TableColumnSchemaEditor/Validators/EntityIdSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;GAEG;AACH,eAAO,MAAM,cAAc,wCAIzB,CAAA"}
+{"version":3,"file":"EntityIdSchema.d.ts","sourceRoot":"","sources":["../../../../src/components/TableColumnSchemaEditor/Validators/EntityIdSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;GAEG;AACH,eAAO,MAAM,cAAc,iDAIzB,CAAA"}

package/dist/components/TableColumnSchemaEditor/Validators/IntegerSchema.d.ts

@@ -2,5 +2,5 @@ import { z } from 'zod';
 /**
  * Validates and converts a value to a valid Synapse INTEGER value
  */
-export declare const integerSchema: z.ZodPipeline<z.ZodUnion<[z.ZodEffects<z.ZodString, string | null, string>, z.ZodNull, z.ZodNumber]>, z.ZodUnion<[z.ZodNull, z.ZodNumber]>>;
+export declare const integerSchema: z.ZodPipe<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<number | null, string>>, z.ZodNull, z.ZodNumber]>, z.ZodUnion<readonly [z.ZodNull, z.ZodNumber]>>;
 //# sourceMappingURL=IntegerSchema.d.ts.map

package/dist/components/TableColumnSchemaEditor/Validators/IntegerSchema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IntegerSchema.d.ts","sourceRoot":"","sources":["../../../../src/components/TableColumnSchemaEditor/Validators/IntegerSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;GAEG;AACH,eAAO,MAAM,aAAa,6IAS2B,CAAA"}
+{"version":3,"file":"IntegerSchema.d.ts","sourceRoot":"","sources":["../../../../src/components/TableColumnSchemaEditor/Validators/IntegerSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;GAEG;AACH,eAAO,MAAM,aAAa,wKASoB,CAAA"}

package/dist/components/TableColumnSchemaEditor/Validators/IntegerSchema.js

@@ -1,10 +1,10 @@
 import { z as e } from "zod";
 //#region src/components/TableColumnSchemaEditor/Validators/IntegerSchema.ts
 var t = e.union([
-	e.string().transform((e) => e === "" ? null : e),
+	e.string().transform((e) => e === "" ? null : Number(e)),
 	e.null(),
 	e.number().int()
-]).pipe(e.union([e.null(), e.coerce.number().int()]));
+]).pipe(e.union([e.null(), e.number().int()]));
 //#endregion
 export { t as integerSchema };
 

package/dist/components/TableColumnSchemaEditor/Validators/IntegerSchema.js.map

@@ -1 +1 @@
-{"version":3,"file":"IntegerSchema.js","names":[],"sources":["../../../../src/components/TableColumnSchemaEditor/Validators/IntegerSchema.ts"],"sourcesContent":["import { z } from 'zod'\n\n/**\n * Validates and converts a value to a valid Synapse INTEGER value\n */\nexport const integerSchema = z\n  .union([\n    z\n      .string()\n      // Transform empty string to null\n      .transform(data => (data === '' ? null : data)),\n    z.null(),\n    z.number().int(),\n  ])\n  .pipe(z.union([z.null(), z.coerce.number().int()]))\n"],"mappings":";;AAKA,IAAa,IAAgB,EAC1B,MAAM;CACL,EACG,OAAO,EAEP,WAAU,MAAS,MAAS,KAAK,OAAO,CAAK;CAChD,EAAE,KAAK;CACP,EAAE,OAAO,EAAE,IAAI;AACjB,CAAC,EACA,KAAK,EAAE,MAAM,CAAC,EAAE,KAAK,GAAG,EAAE,OAAO,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC"}
+{"version":3,"file":"IntegerSchema.js","names":[],"sources":["../../../../src/components/TableColumnSchemaEditor/Validators/IntegerSchema.ts"],"sourcesContent":["import { z } from 'zod'\n\n/**\n * Validates and converts a value to a valid Synapse INTEGER value\n */\nexport const integerSchema = z\n  .union([\n    z\n      .string()\n      // Transform empty string to null, otherwise convert to a number\n      .transform(data => (data === '' ? null : Number(data))),\n    z.null(),\n    z.number().int(),\n  ])\n  .pipe(z.union([z.null(), z.number().int()]))\n"],"mappings":";;AAKA,IAAa,IAAgB,EAC1B,MAAM;CACL,EACG,OAAO,EAEP,WAAU,MAAS,MAAS,KAAK,OAAO,OAAO,CAAI,CAAE;CACxD,EAAE,KAAK;CACP,EAAE,OAAO,EAAE,IAAI;AACjB,CAAC,EACA,KAAK,EAAE,MAAM,CAAC,EAAE,KAAK,GAAG,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC"}

package/dist/components/TableColumnSchemaEditor/Validators/OptionalStringSchema.d.ts

@@ -2,5 +2,5 @@ import { z } from 'zod';
 /**
  * Schema for an optional string. Converts empty string to undefined.
  */
-export declare const optionalStringSchema: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>;
+export declare const optionalStringSchema: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
 //# sourceMappingURL=OptionalStringSchema.d.ts.map

package/dist/components/TableColumnSchemaEditor/Validators/OptionalStringSchema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OptionalStringSchema.d.ts","sourceRoot":"","sources":["../../../../src/components/TableColumnSchemaEditor/Validators/OptionalStringSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;GAEG;AACH,eAAO,MAAM,oBAAoB,kFAGY,CAAA"}
+{"version":3,"file":"OptionalStringSchema.d.ts","sourceRoot":"","sources":["../../../../src/components/TableColumnSchemaEditor/Validators/OptionalStringSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;GAEG;AACH,eAAO,MAAM,oBAAoB,+FAGY,CAAA"}

package/dist/components/TableColumnSchemaEditor/Validators/getZodSchemaForColumnType.d.ts

@@ -1,4 +1,4 @@
 import { ColumnTypeEnum } from '@sage-bionetworks/synapse-types';
-import { ZodTypeAny } from 'zod';
-export default function getZodSchemaForColumnType(columnType: ColumnTypeEnum): ZodTypeAny;
+import { ZodType } from 'zod';
+export default function getZodSchemaForColumnType(columnType: ColumnTypeEnum): ZodType;
 //# sourceMappingURL=getZodSchemaForColumnType.d.ts.map

package/dist/components/TableColumnSchemaEditor/Validators/getZodSchemaForColumnType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getZodSchemaForColumnType.d.ts","sourceRoot":"","sources":["../../../../src/components/TableColumnSchemaEditor/Validators/getZodSchemaForColumnType.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAA;AAEhE,OAAO,EAAK,UAAU,EAAE,MAAM,KAAK,CAAA;AAyBnC,MAAM,CAAC,OAAO,UAAU,yBAAyB,CAC/C,UAAU,EAAE,cAAc,GACzB,UAAU,CAoDZ"}
+{"version":3,"file":"getZodSchemaForColumnType.d.ts","sourceRoot":"","sources":["../../../../src/components/TableColumnSchemaEditor/Validators/getZodSchemaForColumnType.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAA;AAEhE,OAAO,EAAK,OAAO,EAAE,MAAM,KAAK,CAAA;AA0BhC,MAAM,CAAC,OAAO,UAAU,yBAAyB,CAC/C,UAAU,EAAE,cAAc,GACzB,OAAO,CA6CT"}

package/dist/components/TableColumnSchemaEditor/Validators/getZodSchemaForColumnType.js

@@ -9,17 +9,16 @@ import { z as o } from "zod";
 var s = o.string().transform((e, t) => {
 	try {
 		let n = JSON.parse(e);
-		return Array.isArray(n) || t.addIssue({
-			code: o.ZodIssueCode.custom,
+		return Array.isArray(n) ? n : (t.addIssue({
+			code: "custom",
 			message: "Object was valid JSON, but was not an array"
-		}), n;
+		}), o.NEVER);
 	} catch {
-		t.addIssue({
-			code: o.ZodIssueCode.custom,
+		return t.addIssue({
+			code: "custom",
 			message: "Invalid JSON array"
-		});
+		}), o.NEVER;
 	}
-	return e;
 });
 function c(l) {
 	if (l.endsWith("_LIST")) {
@@ -27,19 +26,19 @@ function c(l) {
 		return o.union([o.array(e), s.pipe(o.array(e))]);
 	}
 	switch (l) {
-		case a.STRING: return o.coerce.string();
+		case a.STRING:
+		case a.LINK:
+		case a.MEDIUMTEXT:
+		case a.LARGETEXT: return o.coerce.string();
 		case a.BOOLEAN: return n;
-		case a.INTEGER: return r;
+		case a.INTEGER:
+		case a.FILEHANDLEID:
+		case a.USERID:
+		case a.EVALUATIONID:
+		case a.SUBMISSIONID: return r;
 		case a.DOUBLE: return e;
 		case a.DATE: return t;
-		case a.FILEHANDLEID: return r;
 		case a.ENTITYID: return i;
-		case a.LINK: return o.coerce.string();
-		case a.MEDIUMTEXT: return o.coerce.string();
-		case a.LARGETEXT: return o.coerce.string();
-		case a.USERID: return r;
-		case a.EVALUATIONID: return r;
-		case a.SUBMISSIONID: return r;
 		case a.JSON: return o.string().refine((e) => {
 			try {
 				return JSON.parse(e), !0;

package/dist/components/TableColumnSchemaEditor/Validators/getZodSchemaForColumnType.js.map

@@ -1 +1 @@
-{"version":3,"file":"getZodSchemaForColumnType.js","names":[],"sources":["../../../../src/components/TableColumnSchemaEditor/Validators/getZodSchemaForColumnType.ts"],"sourcesContent":["import { ColumnTypeEnum } from '@sage-bionetworks/synapse-types'\nimport { doubleSchema } from './DoubleSchema'\nimport { z, ZodTypeAny } from 'zod'\nimport { dateTimeSchema } from './DatetimeSchema'\nimport { booleanSchema } from './BooleanSchema'\nimport { integerSchema } from './IntegerSchema'\nimport { entityIdSchema } from './EntityIdSchema'\n\nconst arraySerializedAsStringSchema = z.string().transform((data, ctx) => {\n  try {\n    const parsed = JSON.parse(data)\n    if (!Array.isArray(parsed)) {\n      ctx.addIssue({\n        code: z.ZodIssueCode.custom,\n        message: 'Object was valid JSON, but was not an array',\n      })\n    }\n    return parsed\n  } catch (e) {\n    ctx.addIssue({\n      code: z.ZodIssueCode.custom,\n      message: 'Invalid JSON array',\n    })\n  }\n  return data\n})\n\nexport default function getZodSchemaForColumnType(\n  columnType: ColumnTypeEnum,\n): ZodTypeAny {\n  if (columnType.endsWith('_LIST')) {\n    const baseSchema = getZodSchemaForColumnType(\n      columnType.replace('_LIST', '') as ColumnTypeEnum,\n    )\n    return z.union([\n      z.array(baseSchema),\n      // Also handle cases where the array is serialized as a string\n      arraySerializedAsStringSchema.pipe(z.array(baseSchema)),\n    ])\n  }\n\n  switch (columnType) {\n    case ColumnTypeEnum.STRING:\n      return z.coerce.string()\n    case ColumnTypeEnum.BOOLEAN:\n      return booleanSchema\n    case ColumnTypeEnum.INTEGER:\n      return integerSchema\n    case ColumnTypeEnum.DOUBLE:\n      return doubleSchema\n    case ColumnTypeEnum.DATE:\n      return dateTimeSchema\n    case ColumnTypeEnum.FILEHANDLEID:\n      return integerSchema\n    case ColumnTypeEnum.ENTITYID:\n      return entityIdSchema\n    case ColumnTypeEnum.LINK:\n      return z.coerce.string()\n    case ColumnTypeEnum.MEDIUMTEXT:\n      return z.coerce.string()\n    case ColumnTypeEnum.LARGETEXT:\n      return z.coerce.string()\n    case ColumnTypeEnum.USERID:\n      return integerSchema\n    case ColumnTypeEnum.EVALUATIONID:\n      return integerSchema\n    case ColumnTypeEnum.SUBMISSIONID:\n      return integerSchema\n    case ColumnTypeEnum.JSON:\n      return z.string().refine(v => {\n        try {\n          JSON.parse(v)\n          return true\n        } catch (e) {\n          return false\n        }\n      })\n    default:\n      console.warn(`No validator for column type ${columnType}`)\n      return z.any()\n  }\n}\n"],"mappings":";;;;;;;;AAQA,IAAM,IAAgC,EAAE,OAAO,EAAE,WAAW,GAAM,MAAQ;CACxE,IAAI;EACF,IAAM,IAAS,KAAK,MAAM,CAAI;EAO9B,OANK,MAAM,QAAQ,CAAM,KACvB,EAAI,SAAS;GACX,MAAM,EAAE,aAAa;GACrB,SAAS;EACX,CAAC,GAEI;CACT,QAAY;EACV,EAAI,SAAS;GACX,MAAM,EAAE,aAAa;GACrB,SAAS;EACX,CAAC;CACH;CACA,OAAO;AACT,CAAC;AAED,SAAwB,EACtB,GACY;CACZ,IAAI,EAAW,SAAS,OAAO,GAAG;EAChC,IAAM,IAAa,EACjB,EAAW,QAAQ,SAAS,EAAE,CAChC;EACA,OAAO,EAAE,MAAM,CACb,EAAE,MAAM,CAAU,GAElB,EAA8B,KAAK,EAAE,MAAM,CAAU,CAAC,CACxD,CAAC;CACH;CAEA,QAAQ,GAAR;EACE,KAAK,EAAe,QAClB,OAAO,EAAE,OAAO,OAAO;EACzB,KAAK,EAAe,SAClB,OAAO;EACT,KAAK,EAAe,SAClB,OAAO;EACT,KAAK,EAAe,QAClB,OAAO;EACT,KAAK,EAAe,MAClB,OAAO;EACT,KAAK,EAAe,cAClB,OAAO;EACT,KAAK,EAAe,UAClB,OAAO;EACT,KAAK,EAAe,MAClB,OAAO,EAAE,OAAO,OAAO;EACzB,KAAK,EAAe,YAClB,OAAO,EAAE,OAAO,OAAO;EACzB,KAAK,EAAe,WAClB,OAAO,EAAE,OAAO,OAAO;EACzB,KAAK,EAAe,QAClB,OAAO;EACT,KAAK,EAAe,cAClB,OAAO;EACT,KAAK,EAAe,cAClB,OAAO;EACT,KAAK,EAAe,MAClB,OAAO,EAAE,OAAO,EAAE,QAAO,MAAK;GAC5B,IAAI;IAEF,OADA,KAAK,MAAM,CAAC,GACL;GACT,QAAY;IACV,OAAO;GACT;EACF,CAAC;EACH,SAEE,OADA,QAAQ,KAAK,gCAAgC,GAAY,GAClD,EAAE,IAAI;CACjB;AACF"}
+{"version":3,"file":"getZodSchemaForColumnType.js","names":[],"sources":["../../../../src/components/TableColumnSchemaEditor/Validators/getZodSchemaForColumnType.ts"],"sourcesContent":["import { ColumnTypeEnum } from '@sage-bionetworks/synapse-types'\nimport { doubleSchema } from './DoubleSchema'\nimport { z, ZodType } from 'zod'\nimport { dateTimeSchema } from './DatetimeSchema'\nimport { booleanSchema } from './BooleanSchema'\nimport { integerSchema } from './IntegerSchema'\nimport { entityIdSchema } from './EntityIdSchema'\n\nconst arraySerializedAsStringSchema = z.string().transform((data, ctx) => {\n  try {\n    const parsed = JSON.parse(data)\n    if (!Array.isArray(parsed)) {\n      ctx.addIssue({\n        code: 'custom',\n        message: 'Object was valid JSON, but was not an array',\n      })\n      return z.NEVER\n    }\n    return parsed\n  } catch (e) {\n    ctx.addIssue({\n      code: 'custom',\n      message: 'Invalid JSON array',\n    })\n    return z.NEVER\n  }\n})\n\nexport default function getZodSchemaForColumnType(\n  columnType: ColumnTypeEnum,\n): ZodType {\n  if (columnType.endsWith('_LIST')) {\n    const baseSchema = getZodSchemaForColumnType(\n      columnType.replace('_LIST', '') as ColumnTypeEnum,\n    )\n    return z.union([\n      z.array(baseSchema),\n      // Also handle cases where the array is serialized as a string\n      arraySerializedAsStringSchema.pipe(z.array(baseSchema)),\n    ])\n  }\n\n  switch (columnType) {\n    case ColumnTypeEnum.STRING:\n    case ColumnTypeEnum.LINK:\n    case ColumnTypeEnum.MEDIUMTEXT:\n    case ColumnTypeEnum.LARGETEXT:\n      return z.coerce.string()\n    case ColumnTypeEnum.BOOLEAN:\n      return booleanSchema\n    case ColumnTypeEnum.INTEGER:\n    case ColumnTypeEnum.FILEHANDLEID:\n    case ColumnTypeEnum.USERID:\n    case ColumnTypeEnum.EVALUATIONID:\n    case ColumnTypeEnum.SUBMISSIONID:\n      return integerSchema\n    case ColumnTypeEnum.DOUBLE:\n      return doubleSchema\n    case ColumnTypeEnum.DATE:\n      return dateTimeSchema\n    case ColumnTypeEnum.ENTITYID:\n      return entityIdSchema\n    case ColumnTypeEnum.JSON:\n      return z.string().refine(v => {\n        try {\n          JSON.parse(v)\n          return true\n        } catch (e) {\n          return false\n        }\n      })\n    default:\n      console.warn(`No validator for column type ${columnType}`)\n      return z.any()\n  }\n}\n"],"mappings":";;;;;;;;AAQA,IAAM,IAAgC,EAAE,OAAO,EAAE,WAAW,GAAM,MAAQ;CACxE,IAAI;EACF,IAAM,IAAS,KAAK,MAAM,CAAI;EAQ9B,OAPK,MAAM,QAAQ,CAAM,IAOlB,KANL,EAAI,SAAS;GACX,MAAM;GACN,SAAS;EACX,CAAC,GACM,EAAE;CAGb,QAAY;EAKV,OAJA,EAAI,SAAS;GACX,MAAM;GACN,SAAS;EACX,CAAC,GACM,EAAE;CACX;AACF,CAAC;AAED,SAAwB,EACtB,GACS;CACT,IAAI,EAAW,SAAS,OAAO,GAAG;EAChC,IAAM,IAAa,EACjB,EAAW,QAAQ,SAAS,EAAE,CAChC;EACA,OAAO,EAAE,MAAM,CACb,EAAE,MAAM,CAAU,GAElB,EAA8B,KAAK,EAAE,MAAM,CAAU,CAAC,CACxD,CAAC;CACH;CAEA,QAAQ,GAAR;EACE,KAAK,EAAe;EACpB,KAAK,EAAe;EACpB,KAAK,EAAe;EACpB,KAAK,EAAe,WAClB,OAAO,EAAE,OAAO,OAAO;EACzB,KAAK,EAAe,SAClB,OAAO;EACT,KAAK,EAAe;EACpB,KAAK,EAAe;EACpB,KAAK,EAAe;EACpB,KAAK,EAAe;EACpB,KAAK,EAAe,cAClB,OAAO;EACT,KAAK,EAAe,QAClB,OAAO;EACT,KAAK,EAAe,MAClB,OAAO;EACT,KAAK,EAAe,UAClB,OAAO;EACT,KAAK,EAAe,MAClB,OAAO,EAAE,OAAO,EAAE,QAAO,MAAK;GAC5B,IAAI;IAEF,OADA,KAAK,MAAM,CAAC,GACL;GACT,QAAY;IACV,OAAO;GACT;EACF,CAAC;EACH,SAEE,OADA,QAAQ,KAAK,gCAAgC,GAAY,GAClD,EAAE,IAAI;CACjB;AACF"}

package/dist/mocks/mockSearchQueryData.js

@@ -11,8 +11,8 @@ var e = "syn60001", t = "syn60000", n = {
 }, i = {
 	concreteType: "org.sagebionetworks.repo.model.search.table.SearchIndexQuery",
 	searchQuery: {
-		limit: 25,
-		offset: 0
+		size: 25,
+		from: 0
 	}
 }, a = {
 	concreteType: "org.sagebionetworks.repo.model.table.QueryResultBundle",

package/dist/mocks/mockSearchQueryData.js.map

@@ -1 +1 @@
-{"version":3,"file":"mockSearchQueryData.js","names":[],"sources":["../../src/mocks/mockSearchQueryData.ts"],"sourcesContent":["import { QueryResultBundle } from '@sage-bionetworks/synapse-types'\nimport { SearchIndex, SearchIndexQuery } from '@sage-bionetworks/synapse-client'\nimport { MockEntityData } from '@/mocks/entity/MockEntityData'\nimport { Entity } from '@sage-bionetworks/synapse-types'\n\n/** The SearchIndex entity that accepts search API calls and has a definingSql. */\nexport const MOCK_SEARCH_INDEX_ENTITY_ID = 'syn60001'\n/** The underlying Table/View whose schema (column models) backs the search index. */\nexport const MOCK_SEARCH_UNDERLYING_TABLE_ENTITY_ID = 'syn60000'\n\n/** Mock SearchIndex entity whose definingSQL references the underlying table. */\nexport const mockSearchIndexEntity: SearchIndex = {\n  id: MOCK_SEARCH_INDEX_ENTITY_ID,\n  name: 'Mock Search Index',\n  concreteType: 'org.sagebionetworks.repo.model.search.table.SearchIndex',\n  definingSQL: `SELECT * FROM ${MOCK_SEARCH_UNDERLYING_TABLE_ENTITY_ID}`,\n}\n\n/** MockEntityData wrapper so the default entity GET handler can serve syn60001. */\nexport const mockSearchIndexEntityData: MockEntityData = {\n  id: MOCK_SEARCH_INDEX_ENTITY_ID,\n  name: mockSearchIndexEntity.name!,\n  entity: mockSearchIndexEntity as unknown as Entity,\n}\n\nexport const mockSearchIndexQuery: SearchIndexQuery = {\n  concreteType: 'org.sagebionetworks.repo.model.search.table.SearchIndexQuery',\n  searchQuery: {\n    limit: 25,\n    offset: 0,\n  },\n}\n\nexport const mockSearchQueryResultBundle: QueryResultBundle = {\n  concreteType: 'org.sagebionetworks.repo.model.table.QueryResultBundle',\n  queryCount: 53,\n  selectColumns: [\n    { name: 'mature', columnType: 'STRING' },\n    { name: 'acronym', columnType: 'STRING' },\n    { name: 'name', columnType: 'STRING' },\n    { name: 'category', columnType: 'STRING' },\n    { name: 'collections', columnType: 'STRING_LIST' },\n    { name: 'topic', columnType: 'STRING_LIST' },\n    { name: 'dataTypes', columnType: 'STRING_LIST' },\n    { name: 'isOpen', columnType: 'STRING' },\n    { name: 'registration', columnType: 'STRING' },\n  ],\n  columnModels: [\n    {\n      id: '245711',\n      name: 'mature',\n      columnType: 'STRING',\n      maximumSize: 50,\n      facetType: 'enumeration',\n    },\n    { id: '240032', name: 'acronym', columnType: 'STRING', maximumSize: 100 },\n    { id: '244787', name: 'name', columnType: 'STRING', maximumSize: 256 },\n    {\n      id: '245706',\n      name: 'category',\n      columnType: 'STRING',\n      maximumSize: 100,\n      facetType: 'enumeration',\n    },\n    {\n      id: '245526',\n      name: 'collections',\n      columnType: 'STRING_LIST',\n      maximumListLength: 100,\n      facetType: 'enumeration',\n    },\n    {\n      id: '243320',\n      name: 'topic',\n      columnType: 'STRING_LIST',\n      maximumListLength: 100,\n      facetType: 'enumeration',\n    },\n    {\n      id: '240611',\n      name: 'dataTypes',\n      columnType: 'STRING_LIST',\n      maximumListLength: 100,\n      facetType: 'enumeration',\n    },\n    {\n      id: '245712',\n      name: 'isOpen',\n      columnType: 'STRING',\n      maximumSize: 10,\n      facetType: 'enumeration',\n    },\n    {\n      id: '245713',\n      name: 'registration',\n      columnType: 'STRING',\n      maximumSize: 10,\n      facetType: 'enumeration',\n    },\n  ],\n  facets: [\n    {\n      concreteType:\n        'org.sagebionetworks.repo.model.table.FacetColumnResultValues',\n      columnName: 'collections',\n      facetType: 'enumeration',\n      facetValues: [\n        { value: 'Machine Learning Framework', count: 11, isSelected: false },\n        { value: 'File Format', count: 8, isSelected: false },\n        { value: 'OBO Foundry', count: 6, isSelected: false },\n        {\n          value: 'Implementation Maturity Production',\n          count: 5,\n          isSelected: false,\n        },\n        {\n          value: 'Standards Process Maturity Final',\n          count: 4,\n          isSelected: false,\n        },\n        { value: 'Cloud Platform', count: 3, isSelected: false },\n        { value: 'Graph Data Platform', count: 3, isSelected: false },\n        { value: 'Notebook Platform', count: 3, isSelected: false },\n        { value: 'Cloud Service', count: 1, isSelected: false },\n        { value: 'Data Model', count: 1, isSelected: false },\n      ],\n    },\n    {\n      concreteType:\n        'org.sagebionetworks.repo.model.table.FacetColumnResultValues',\n      columnName: 'category',\n      facetType: 'enumeration',\n      facetValues: [\n        { value: 'Software or Tool', count: 33, isSelected: false },\n        { value: 'Biomedical Standard', count: 8, isSelected: false },\n        { value: 'Ontology or Vocabulary', count: 8, isSelected: false },\n        { value: 'Data Standard', count: 2, isSelected: false },\n        { value: 'Training Program', count: 2, isSelected: false },\n      ],\n    },\n    {\n      concreteType:\n        'org.sagebionetworks.repo.model.table.FacetColumnResultValues',\n      columnName: 'topic',\n      facetType: 'enumeration',\n      facetValues: [\n        { value: 'Data', count: 27, isSelected: false },\n        { value: 'Genome', count: 6, isSelected: false },\n        { value: 'Clinical Observations', count: 4, isSelected: false },\n        { value: 'Image', count: 3, isSelected: false },\n        { value: 'Networks And Pathways', count: 3, isSelected: false },\n        { value: 'EHR', count: 2, isSelected: false },\n        { value: 'Gene', count: 2, isSelected: false },\n        { value: 'Training', count: 2, isSelected: false },\n      ],\n    },\n    {\n      concreteType:\n        'org.sagebionetworks.repo.model.table.FacetColumnResultValues',\n      columnName: 'dataTypes',\n      facetType: 'enumeration',\n      facetValues: [\n        { value: 'PyTorch Tensor', count: 3, isSelected: false },\n        { value: 'Array', count: 2, isSelected: false },\n        { value: 'Database', count: 2, isSelected: false },\n        { value: 'Graph', count: 2, isSelected: false },\n        { value: 'Graph Database', count: 2, isSelected: false },\n        { value: 'BED', count: 1, isSelected: false },\n        { value: 'DICOM', count: 1, isSelected: false },\n        { value: 'Neo4j', count: 1, isSelected: false },\n        { value: 'ONNX', count: 1, isSelected: false },\n      ],\n    },\n    {\n      concreteType:\n        'org.sagebionetworks.repo.model.table.FacetColumnResultValues',\n      columnName: 'isOpen',\n      facetType: 'enumeration',\n      facetValues: [\n        { value: 'Yes', count: 50, isSelected: false },\n        { value: 'No', count: 3, isSelected: false },\n      ],\n    },\n    {\n      concreteType:\n        'org.sagebionetworks.repo.model.table.FacetColumnResultValues',\n      columnName: 'mature',\n      facetType: 'enumeration',\n      facetValues: [\n        { value: 'Is Not Mature', count: 48, isSelected: false },\n        { value: 'Is Mature', count: 5, isSelected: false },\n      ],\n    },\n    {\n      concreteType:\n        'org.sagebionetworks.repo.model.table.FacetColumnResultValues',\n      columnName: 'registration',\n      facetType: 'enumeration',\n      facetValues: [\n        { value: 'No', count: 44, isSelected: false },\n        { value: 'Yes', count: 9, isSelected: false },\n      ],\n    },\n  ],\n  queryResult: {\n    concreteType: 'org.sagebionetworks.repo.model.table.QueryResult',\n    queryResults: {\n      concreteType: 'org.sagebionetworks.repo.model.table.RowSet',\n      tableId: MOCK_SEARCH_INDEX_ENTITY_ID,\n      etag: 'search-mock-etag',\n      headers: [\n        { name: 'mature', columnType: 'STRING', id: '245711' },\n        { name: 'acronym', columnType: 'STRING', id: '240032' },\n        { name: 'name', columnType: 'STRING', id: '244787' },\n        { name: 'category', columnType: 'STRING', id: '245706' },\n        { name: 'collections', columnType: 'STRING_LIST', id: '245526' },\n        { name: 'topic', columnType: 'STRING_LIST', id: '243320' },\n        { name: 'dataTypes', columnType: 'STRING_LIST', id: '240611' },\n        { name: 'isOpen', columnType: 'STRING', id: '245712' },\n        { name: 'registration', columnType: 'STRING', id: '245713' },\n      ],\n      rows: [\n        {\n          rowId: 1,\n          versionNumber: 1,\n          values: [\n            'Is Not Mature',\n            'PyTorch',\n            'PyTorch',\n            'Software or Tool',\n            '[\"Machine Learning Framework\"]',\n            '[\"Data\"]',\n            '[\"PyTorch Tensor\"]',\n            'Yes',\n            'No',\n          ],\n        },\n        {\n          rowId: 2,\n          versionNumber: 1,\n          values: [\n            'Is Mature',\n            'TF',\n            'TensorFlow',\n            'Software or Tool',\n            '[\"Machine Learning Framework\"]',\n            '[\"Data\"]',\n            '[\"Tensor\"]',\n            'Yes',\n            'No',\n          ],\n        },\n        {\n          rowId: 3,\n          versionNumber: 1,\n          values: [\n            'Is Not Mature',\n            'HDF5',\n            'Hierarchical Data Format 5',\n            'Data Standard',\n            '[\"File Format\"]',\n            '[\"Data\"]',\n            '[\"Array\"]',\n            'Yes',\n            'No',\n          ],\n        },\n        {\n          rowId: 4,\n          versionNumber: 1,\n          values: [\n            'Is Mature',\n            'DICOM',\n            'Digital Imaging and Communications in Medicine',\n            'Biomedical Standard',\n            '[\"File Format\"]',\n            '[\"Image\"]',\n            '[\"DICOM\"]',\n            'Yes',\n            'No',\n          ],\n        },\n        {\n          rowId: 5,\n          versionNumber: 1,\n          values: [\n            'Is Not Mature',\n            'Neo4j',\n            'Neo4j Graph Database',\n            'Software or Tool',\n            '[\"Graph Data Platform\"]',\n            '[\"Data\"]',\n            '[\"Neo4j\"]',\n            'Yes',\n            'No',\n          ],\n        },\n        {\n          rowId: 6,\n          versionNumber: 1,\n          values: [\n            'Is Mature',\n            'GO',\n            'Gene Ontology',\n            'Ontology or Vocabulary',\n            '[\"OBO Foundry\"]',\n            '[\"Gene\"]',\n            null,\n            'Yes',\n            'No',\n          ],\n        },\n        {\n          rowId: 7,\n          versionNumber: 1,\n          values: [\n            'Is Not Mature',\n            'ONNX',\n            'Open Neural Network Exchange',\n            'Data Standard',\n            '[\"Machine Learning Framework\"]',\n            '[\"Data\"]',\n            '[\"ONNX\"]',\n            'Yes',\n            'No',\n          ],\n        },\n        {\n          rowId: 8,\n          versionNumber: 1,\n          values: [\n            'Is Not Mature',\n            'Jupyter',\n            'JupyterHub',\n            'Software or Tool',\n            '[\"Notebook Platform\"]',\n            '[\"Training\"]',\n            null,\n            'Yes',\n            'No',\n          ],\n        },\n        {\n          rowId: 9,\n          versionNumber: 1,\n          values: [\n            'Is Not Mature',\n            'AWS',\n            'Amazon Web Services',\n            'Software or Tool',\n            '[\"Cloud Platform\"]',\n            '[\"Data\"]',\n            null,\n            'Yes',\n            'Yes',\n          ],\n        },\n        {\n          rowId: 10,\n          versionNumber: 1,\n          values: [\n            'Is Not Mature',\n            'HPO',\n            'Human Phenotype Ontology',\n            'Ontology or Vocabulary',\n            '[\"OBO Foundry\"]',\n            '[\"Clinical Observations\"]',\n            null,\n            'Yes',\n            'No',\n          ],\n        },\n      ],\n    },\n  },\n}\n"],"mappings":"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IACA;KACE,OAAO;KACP,eAAe;KACf,QAAQ;MACN;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;KACF;IACF;IACA;KACE,OAAO;KACP,eAAe;KACf,QAAQ;MACN;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;KACF;IACF;IACA;KACE,OAAO;KACP,eAAe;KACf,QAAQ;MACN;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;KACF;IACF;IACA;KACE,OAAO;KACP,eAAe;KACf,QAAQ;MACN;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;KACF;IACF;IACA;KACE,OAAO;KACP,eAAe;KACf,QAAQ;MACN;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;KACF;IACF;IACA;KACE,OAAO;KACP,eAAe;KACf,QAAQ;MACN;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;KACF;IACF;IACA;KACE,OAAO;KACP,eAAe;KACf,QAAQ;MACN;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;KACF;IACF;IACA;KACE,OAAO;KACP,eAAe;KACf,QAAQ;MACN;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;KACF;IACF;IACA;KACE,OAAO;KACP,eAAe;KACf,QAAQ;MACN;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;KACF;IACF;GACF;EACF;CACF;AACF"}
+{"version":3,"file":"mockSearchQueryData.js","names":[],"sources":["../../src/mocks/mockSearchQueryData.ts"],"sourcesContent":["import { QueryResultBundle } from '@sage-bionetworks/synapse-types'\nimport { SearchIndex, SearchIndexQuery } from '@sage-bionetworks/synapse-client'\nimport { MockEntityData } from '@/mocks/entity/MockEntityData'\nimport { Entity } from '@sage-bionetworks/synapse-types'\n\n/** The SearchIndex entity that accepts search API calls and has a definingSql. */\nexport const MOCK_SEARCH_INDEX_ENTITY_ID = 'syn60001'\n/** The underlying Table/View whose schema (column models) backs the search index. */\nexport const MOCK_SEARCH_UNDERLYING_TABLE_ENTITY_ID = 'syn60000'\n\n/** Mock SearchIndex entity whose definingSQL references the underlying table. */\nexport const mockSearchIndexEntity: SearchIndex = {\n  id: MOCK_SEARCH_INDEX_ENTITY_ID,\n  name: 'Mock Search Index',\n  concreteType: 'org.sagebionetworks.repo.model.search.table.SearchIndex',\n  definingSQL: `SELECT * FROM ${MOCK_SEARCH_UNDERLYING_TABLE_ENTITY_ID}`,\n}\n\n/** MockEntityData wrapper so the default entity GET handler can serve syn60001. */\nexport const mockSearchIndexEntityData: MockEntityData = {\n  id: MOCK_SEARCH_INDEX_ENTITY_ID,\n  name: mockSearchIndexEntity.name!,\n  entity: mockSearchIndexEntity as unknown as Entity,\n}\n\nexport const mockSearchIndexQuery: SearchIndexQuery = {\n  concreteType: 'org.sagebionetworks.repo.model.search.table.SearchIndexQuery',\n  searchQuery: {\n    size: 25,\n    from: 0,\n  },\n}\n\nexport const mockSearchQueryResultBundle: QueryResultBundle = {\n  concreteType: 'org.sagebionetworks.repo.model.table.QueryResultBundle',\n  queryCount: 53,\n  selectColumns: [\n    { name: 'mature', columnType: 'STRING' },\n    { name: 'acronym', columnType: 'STRING' },\n    { name: 'name', columnType: 'STRING' },\n    { name: 'category', columnType: 'STRING' },\n    { name: 'collections', columnType: 'STRING_LIST' },\n    { name: 'topic', columnType: 'STRING_LIST' },\n    { name: 'dataTypes', columnType: 'STRING_LIST' },\n    { name: 'isOpen', columnType: 'STRING' },\n    { name: 'registration', columnType: 'STRING' },\n  ],\n  columnModels: [\n    {\n      id: '245711',\n      name: 'mature',\n      columnType: 'STRING',\n      maximumSize: 50,\n      facetType: 'enumeration',\n    },\n    { id: '240032', name: 'acronym', columnType: 'STRING', maximumSize: 100 },\n    { id: '244787', name: 'name', columnType: 'STRING', maximumSize: 256 },\n    {\n      id: '245706',\n      name: 'category',\n      columnType: 'STRING',\n      maximumSize: 100,\n      facetType: 'enumeration',\n    },\n    {\n      id: '245526',\n      name: 'collections',\n      columnType: 'STRING_LIST',\n      maximumListLength: 100,\n      facetType: 'enumeration',\n    },\n    {\n      id: '243320',\n      name: 'topic',\n      columnType: 'STRING_LIST',\n      maximumListLength: 100,\n      facetType: 'enumeration',\n    },\n    {\n      id: '240611',\n      name: 'dataTypes',\n      columnType: 'STRING_LIST',\n      maximumListLength: 100,\n      facetType: 'enumeration',\n    },\n    {\n      id: '245712',\n      name: 'isOpen',\n      columnType: 'STRING',\n      maximumSize: 10,\n      facetType: 'enumeration',\n    },\n    {\n      id: '245713',\n      name: 'registration',\n      columnType: 'STRING',\n      maximumSize: 10,\n      facetType: 'enumeration',\n    },\n  ],\n  facets: [\n    {\n      concreteType:\n        'org.sagebionetworks.repo.model.table.FacetColumnResultValues',\n      columnName: 'collections',\n      facetType: 'enumeration',\n      facetValues: [\n        { value: 'Machine Learning Framework', count: 11, isSelected: false },\n        { value: 'File Format', count: 8, isSelected: false },\n        { value: 'OBO Foundry', count: 6, isSelected: false },\n        {\n          value: 'Implementation Maturity Production',\n          count: 5,\n          isSelected: false,\n        },\n        {\n          value: 'Standards Process Maturity Final',\n          count: 4,\n          isSelected: false,\n        },\n        { value: 'Cloud Platform', count: 3, isSelected: false },\n        { value: 'Graph Data Platform', count: 3, isSelected: false },\n        { value: 'Notebook Platform', count: 3, isSelected: false },\n        { value: 'Cloud Service', count: 1, isSelected: false },\n        { value: 'Data Model', count: 1, isSelected: false },\n      ],\n    },\n    {\n      concreteType:\n        'org.sagebionetworks.repo.model.table.FacetColumnResultValues',\n      columnName: 'category',\n      facetType: 'enumeration',\n      facetValues: [\n        { value: 'Software or Tool', count: 33, isSelected: false },\n        { value: 'Biomedical Standard', count: 8, isSelected: false },\n        { value: 'Ontology or Vocabulary', count: 8, isSelected: false },\n        { value: 'Data Standard', count: 2, isSelected: false },\n        { value: 'Training Program', count: 2, isSelected: false },\n      ],\n    },\n    {\n      concreteType:\n        'org.sagebionetworks.repo.model.table.FacetColumnResultValues',\n      columnName: 'topic',\n      facetType: 'enumeration',\n      facetValues: [\n        { value: 'Data', count: 27, isSelected: false },\n        { value: 'Genome', count: 6, isSelected: false },\n        { value: 'Clinical Observations', count: 4, isSelected: false },\n        { value: 'Image', count: 3, isSelected: false },\n        { value: 'Networks And Pathways', count: 3, isSelected: false },\n        { value: 'EHR', count: 2, isSelected: false },\n        { value: 'Gene', count: 2, isSelected: false },\n        { value: 'Training', count: 2, isSelected: false },\n      ],\n    },\n    {\n      concreteType:\n        'org.sagebionetworks.repo.model.table.FacetColumnResultValues',\n      columnName: 'dataTypes',\n      facetType: 'enumeration',\n      facetValues: [\n        { value: 'PyTorch Tensor', count: 3, isSelected: false },\n        { value: 'Array', count: 2, isSelected: false },\n        { value: 'Database', count: 2, isSelected: false },\n        { value: 'Graph', count: 2, isSelected: false },\n        { value: 'Graph Database', count: 2, isSelected: false },\n        { value: 'BED', count: 1, isSelected: false },\n        { value: 'DICOM', count: 1, isSelected: false },\n        { value: 'Neo4j', count: 1, isSelected: false },\n        { value: 'ONNX', count: 1, isSelected: false },\n      ],\n    },\n    {\n      concreteType:\n        'org.sagebionetworks.repo.model.table.FacetColumnResultValues',\n      columnName: 'isOpen',\n      facetType: 'enumeration',\n      facetValues: [\n        { value: 'Yes', count: 50, isSelected: false },\n        { value: 'No', count: 3, isSelected: false },\n      ],\n    },\n    {\n      concreteType:\n        'org.sagebionetworks.repo.model.table.FacetColumnResultValues',\n      columnName: 'mature',\n      facetType: 'enumeration',\n      facetValues: [\n        { value: 'Is Not Mature', count: 48, isSelected: false },\n        { value: 'Is Mature', count: 5, isSelected: false },\n      ],\n    },\n    {\n      concreteType:\n        'org.sagebionetworks.repo.model.table.FacetColumnResultValues',\n      columnName: 'registration',\n      facetType: 'enumeration',\n      facetValues: [\n        { value: 'No', count: 44, isSelected: false },\n        { value: 'Yes', count: 9, isSelected: false },\n      ],\n    },\n  ],\n  queryResult: {\n    concreteType: 'org.sagebionetworks.repo.model.table.QueryResult',\n    queryResults: {\n      concreteType: 'org.sagebionetworks.repo.model.table.RowSet',\n      tableId: MOCK_SEARCH_INDEX_ENTITY_ID,\n      etag: 'search-mock-etag',\n      headers: [\n        { name: 'mature', columnType: 'STRING', id: '245711' },\n        { name: 'acronym', columnType: 'STRING', id: '240032' },\n        { name: 'name', columnType: 'STRING', id: '244787' },\n        { name: 'category', columnType: 'STRING', id: '245706' },\n        { name: 'collections', columnType: 'STRING_LIST', id: '245526' },\n        { name: 'topic', columnType: 'STRING_LIST', id: '243320' },\n        { name: 'dataTypes', columnType: 'STRING_LIST', id: '240611' },\n        { name: 'isOpen', columnType: 'STRING', id: '245712' },\n        { name: 'registration', columnType: 'STRING', id: '245713' },\n      ],\n      rows: [\n        {\n          rowId: 1,\n          versionNumber: 1,\n          values: [\n            'Is Not Mature',\n            'PyTorch',\n            'PyTorch',\n            'Software or Tool',\n            '[\"Machine Learning Framework\"]',\n            '[\"Data\"]',\n            '[\"PyTorch Tensor\"]',\n            'Yes',\n            'No',\n          ],\n        },\n        {\n          rowId: 2,\n          versionNumber: 1,\n          values: [\n            'Is Mature',\n            'TF',\n            'TensorFlow',\n            'Software or Tool',\n            '[\"Machine Learning Framework\"]',\n            '[\"Data\"]',\n            '[\"Tensor\"]',\n            'Yes',\n            'No',\n          ],\n        },\n        {\n          rowId: 3,\n          versionNumber: 1,\n          values: [\n            'Is Not Mature',\n            'HDF5',\n            'Hierarchical Data Format 5',\n            'Data Standard',\n            '[\"File Format\"]',\n            '[\"Data\"]',\n            '[\"Array\"]',\n            'Yes',\n            'No',\n          ],\n        },\n        {\n          rowId: 4,\n          versionNumber: 1,\n          values: [\n            'Is Mature',\n            'DICOM',\n            'Digital Imaging and Communications in Medicine',\n            'Biomedical Standard',\n            '[\"File Format\"]',\n            '[\"Image\"]',\n            '[\"DICOM\"]',\n            'Yes',\n            'No',\n          ],\n        },\n        {\n          rowId: 5,\n          versionNumber: 1,\n          values: [\n            'Is Not Mature',\n            'Neo4j',\n            'Neo4j Graph Database',\n            'Software or Tool',\n            '[\"Graph Data Platform\"]',\n            '[\"Data\"]',\n            '[\"Neo4j\"]',\n            'Yes',\n            'No',\n          ],\n        },\n        {\n          rowId: 6,\n          versionNumber: 1,\n          values: [\n            'Is Mature',\n            'GO',\n            'Gene Ontology',\n            'Ontology or Vocabulary',\n            '[\"OBO Foundry\"]',\n            '[\"Gene\"]',\n            null,\n            'Yes',\n            'No',\n          ],\n        },\n        {\n          rowId: 7,\n          versionNumber: 1,\n          values: [\n            'Is Not Mature',\n            'ONNX',\n            'Open Neural Network Exchange',\n            'Data Standard',\n            '[\"Machine Learning Framework\"]',\n            '[\"Data\"]',\n            '[\"ONNX\"]',\n            'Yes',\n            'No',\n          ],\n        },\n        {\n          rowId: 8,\n          versionNumber: 1,\n          values: [\n            'Is Not Mature',\n            'Jupyter',\n            'JupyterHub',\n            'Software or Tool',\n            '[\"Notebook Platform\"]',\n            '[\"Training\"]',\n            null,\n            'Yes',\n            'No',\n          ],\n        },\n        {\n          rowId: 9,\n          versionNumber: 1,\n          values: [\n            'Is Not Mature',\n            'AWS',\n            'Amazon Web Services',\n            'Software or Tool',\n            '[\"Cloud Platform\"]',\n            '[\"Data\"]',\n            null,\n            'Yes',\n            'Yes',\n          ],\n        },\n        {\n          rowId: 10,\n          versionNumber: 1,\n          values: [\n            'Is Not Mature',\n            'HPO',\n            'Human Phenotype Ontology',\n            'Ontology or Vocabulary',\n            '[\"OBO Foundry\"]',\n            '[\"Clinical Observations\"]',\n            null,\n            'Yes',\n            'No',\n          ],\n        },\n      ],\n    },\n  },\n}\n"],"mappings":"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IACA;KACE,OAAO;KACP,eAAe;KACf,QAAQ;MACN;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;KACF;IACF;IACA;KACE,OAAO;KACP,eAAe;KACf,QAAQ;MACN;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;KACF;IACF;IACA;KACE,OAAO;KACP,eAAe;KACf,QAAQ;MACN;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;KACF;IACF;IACA;KACE,OAAO;KACP,eAAe;KACf,QAAQ;MACN;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;KACF;IACF;IACA;KACE,OAAO;KACP,eAAe;KACf,QAAQ;MACN;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;KACF;IACF;IACA;KACE,OAAO;KACP,eAAe;KACf,QAAQ;MACN;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;KACF;IACF;IACA;KACE,OAAO;KACP,eAAe;KACf,QAAQ;MACN;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;KACF;IACF;IACA;KACE,OAAO;KACP,eAAe;KACf,QAAQ;MACN;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;KACF;IACF;IACA;KACE,OAAO;KACP,eAAe;KACf,QAAQ;MACN;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;KACF;IACF;GACF;EACF;CACF;AACF"}

package/dist/mocks/msw/handlers/searchQueryHandlers.d.ts

@@ -6,7 +6,7 @@ import { HttpHandler } from 'msw';
  * Used to match registered bindings against incoming requests.
  */
 type SearchIndexQueryKey = Omit<SearchIndexQuery, 'searchQuery'> & {
-    searchQuery?: Omit<SearchSearchQuery, 'limit' | 'offset'>;
+    searchQuery?: Omit<SearchSearchQuery, 'size' | 'from'>;
 };
 /**
  * Register a specific query binding for the mock search service.

package/dist/mocks/msw/handlers/searchQueryHandlers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"searchQueryHandlers.d.ts","sourceRoot":"","sources":["../../../../src/mocks/msw/handlers/searchQueryHandlers.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAA;AACnE,OAAO,EACL,gBAAgB,EAEhB,iBAAiB,EAClB,MAAM,kCAAkC,CAAA;AAEzC,OAAO,EAAE,WAAW,EAAE,MAAM,KAAK,CAAA;AAKjC;;;GAGG;AACH,KAAK,mBAAmB,GAAG,IAAI,CAAC,gBAAgB,EAAE,aAAa,CAAC,GAAG;IACjE,WAAW,CAAC,EAAE,IAAI,CAAC,iBAAiB,EAAE,OAAO,GAAG,QAAQ,CAAC,CAAA;CAC1D,CAAA;AAwCD;;;GAGG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,mBAAmB,EAC7B,MAAM,EAAE,iBAAiB,QAQ1B;AAiDD;;;GAGG;AACH,wBAAgB,yBAAyB,CACvC,aAAa,SAAoD,GAChE,WAAW,EAAE,CAOf"}
+{"version":3,"file":"searchQueryHandlers.d.ts","sourceRoot":"","sources":["../../../../src/mocks/msw/handlers/searchQueryHandlers.ts"],"names":[],"mappings":"AAQA,OAAO,EAEL,iBAAiB,EAClB,MAAM,iCAAiC,CAAA;AACxC,OAAO,EACL,gBAAgB,EAEhB,iBAAiB,EAClB,MAAM,kCAAkC,CAAA;AAEzC,OAAO,EAAE,WAAW,EAAE,MAAM,KAAK,CAAA;AAKjC;;;GAGG;AACH,KAAK,mBAAmB,GAAG,IAAI,CAAC,gBAAgB,EAAE,aAAa,CAAC,GAAG;IACjE,WAAW,CAAC,EAAE,IAAI,CAAC,iBAAiB,EAAE,MAAM,GAAG,MAAM,CAAC,CAAA;CACvD,CAAA;AAwCD;;;GAGG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,mBAAmB,EAC7B,MAAM,EAAE,iBAAiB,QAQ1B;AAmED;;;GAGG;AACH,wBAAgB,yBAAyB,CACvC,aAAa,SAAoD,GAChE,WAAW,EAAE,CAOf"}

package/dist/mocks/msw/handlers/searchQueryHandlers.js

@@ -14,7 +14,7 @@ function l(e, t = 25, n = 0) {
 	return r.queryResult?.queryResults.rows && (r.queryResult.queryResults.rows = r.queryResult.queryResults.rows.slice(n, n + t)), r;
 }
 function u(e, t) {
-	return l(t, e.searchQuery?.limit, e.searchQuery?.offset);
+	return l(t, e.searchQuery?.size, e.searchQuery?.from);
 }
 function d(e, t) {
 	let n = c.getOneByField("queryKey", e);
@@ -28,7 +28,7 @@ function d(e, t) {
 }
 function f(e) {
 	let t = s(e);
-	t.searchQuery && (delete t.searchQuery.limit, delete t.searchQuery.offset);
+	t.searchQuery && (delete t.searchQuery.size, delete t.searchQuery.from);
 	let n = t;
 	return u(e, c.getOneByField("queryKey", n)?.result ?? i);
 }
@@ -50,7 +50,10 @@ function p(e) {
 		totalHits: e.queryCount,
 		hits: n,
 		selectColumns: r,
-		facets: e.facets,
+		aggregationResults: Object.fromEntries((e.facets ?? []).filter((e) => e.concreteType === "org.sagebionetworks.repo.model.table.FacetColumnResultValues").map((e) => [e.columnName, { buckets: (e.facetValues ?? []).map((e) => ({
+			key: e.value,
+			doc_count: e.count
+		})) }])),
 		offset: e.queryResult?.queryResults.rows?.length ? 0 : void 0
 	};
 }