@keboola/api-client 27.0.0 → 31.0.0

package/dist/sdk/semanticLayer/index.cjs

@@ -1,62 +1,360 @@
-'use strict';
-
-var chunkG3JHVIDZ_cjs = require('../../chunk-G3JHVIDZ.cjs');
-require('../../chunk-EWMXK3EI.cjs');
-require('../../chunk-V6FT3RTU.cjs');
-
-
-
-Object.defineProperty(exports, "CONSTRAINT_TYPES", {
-  enumerable: true,
-  get: function () { return chunkG3JHVIDZ_cjs.CONSTRAINT_TYPES; }
-});
-Object.defineProperty(exports, "MODEL_CHILD_OBJECT_TYPES", {
-  enumerable: true,
-  get: function () { return chunkG3JHVIDZ_cjs.MODEL_CHILD_OBJECT_TYPES; }
-});
-Object.defineProperty(exports, "SEMANTIC_CHILD_OBJECT_SCHEMAS", {
-  enumerable: true,
-  get: function () { return chunkG3JHVIDZ_cjs.SEMANTIC_CHILD_OBJECT_SCHEMAS; }
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_concurrent = require("../../concurrent-tbiIa0UL.cjs");
+const require_generateUUID = require("../../generateUUID-C6qKBPIv.cjs");
+let zod = require("zod");
+//#region src/sdks/semanticLayer/semanticLayerSdk.ts
+/**
+* Thrown by `deleteModel` when the child cascade partially fails. Every child delete has
+* settled by the time this is thrown — nothing keeps deleting in the background — and the
+* model itself was kept, so the exact remaining state is knowable: `deletedChildren` are gone,
+* `failedChildren` (and the model) still exist. `errors` carries the per-child rejection
+* reasons, AggregateError-style.
+*/
+var SemanticLayerCascadeDeleteError = class extends AggregateError {
+	modelUUID;
+	deletedChildren;
+	failedChildren;
+	constructor({ modelUUID, deletedChildren, failedChildren }) {
+		const total = deletedChildren.length + failedChildren.length;
+		super(failedChildren.map((failure) => failure.error), `The model was kept because ${failedChildren.length} of its ${total} child objects could not be deleted (${deletedChildren.length} deleted).`);
+		this.name = "SemanticLayerCascadeDeleteError";
+		this.modelUUID = modelUUID;
+		this.deletedChildren = deletedChildren;
+		this.failedChildren = failedChildren;
+	}
+};
+const SEMANTIC_OBJECT_TYPE = {
+	MODEL: "semantic-model",
+	DATASET: "semantic-dataset",
+	METRIC: "semantic-metric",
+	RELATIONSHIP: "semantic-relationship",
+	GLOSSARY: "semantic-glossary",
+	CONSTRAINT: "semantic-constraint"
+};
+/**
+* `readonly` because this drives `createModelTree`, `listModelChildren` and `deleteModel` —
+* a consumer-side `.push()` would silently change what a cascade delete touches.
+*/
+const MODEL_CHILD_OBJECT_TYPES = [
+	SEMANTIC_OBJECT_TYPE.DATASET,
+	SEMANTIC_OBJECT_TYPE.METRIC,
+	SEMANTIC_OBJECT_TYPE.RELATIONSHIP,
+	SEMANTIC_OBJECT_TYPE.GLOSSARY,
+	SEMANTIC_OBJECT_TYPE.CONSTRAINT
+];
+/**
+* The dialects the metastore accepts, exactly as it spells them. A lowercase value is
+* rejected with `422 value must be one of 'Snowflake', 'BigQuery'`, which surfaces only as a
+* generic "Validation failed" — so callers need the real set rather than a bare `string`.
+*
+* `SemanticModelData.sql_dialect` stays `string` for now: narrowing it would break any caller
+* passing a `string` variable, which is a major bump. Validate against this instead.
+*/
+const SQL_DIALECTS = ["Snowflake", "BigQuery"];
+/** The metastore's constraint kinds. Runtime counterpart to `SemanticConstraintType`. */
+const CONSTRAINT_TYPES = [
+	"inequality",
+	"equality",
+	"range",
+	"composition",
+	"exclusion",
+	"temporal",
+	"conditional"
+];
+const DEFAULT_BRANCH = "main";
+const WRITE_CONCURRENCY = 5;
+const mapObject = (item) => ({
+	uuid: item.id,
+	data: item.attributes,
+	meta: item.meta
 });
-Object.defineProperty(exports, "SEMANTIC_OBJECT_TYPE", {
-  enumerable: true,
-  get: function () { return chunkG3JHVIDZ_cjs.SEMANTIC_OBJECT_TYPE; }
+const deriveOptionalObjectName = (data) => {
+	if (typeof data.name === "string") return data.name;
+	if (typeof data.term === "string") return data.term;
+};
+const deriveObjectName = (data) => deriveOptionalObjectName(data) ?? require_generateUUID.generateUUID();
+/**
+* The label a UI shows for an object, as opposed to the identifier it is addressed by.
+*
+* Constraints carry an optional `displayName`; kbc-ui's constraint tables already render
+* `displayName ?? name`, so a confirmation listing what a cascade delete would destroy has to
+* agree with them or it names objects the user can't find on screen.
+*
+* Deliberately **not** used for lookup: `displayName` is optional and not unique, so matching on
+* it would make `findObjectsByName` ambiguous for callers that resolve a write target by name.
+*/
+const deriveObjectLabel = (data) => {
+	if (typeof data.displayName === "string" && data.displayName !== "") return data.displayName;
+	return deriveOptionalObjectName(data);
+};
+const createSemanticLayerSdk = ({ metastoreClient }) => {
+	const _listObjects = async (objectType, signal) => {
+		return (await metastoreClient.repository.getMetaObjects({ objectType }, signal)).data.map(mapObject);
+	};
+	const listModels = async (signal) => _listObjects(SEMANTIC_OBJECT_TYPE.MODEL, signal);
+	const createModel = async (data, meta = {}) => {
+		const response = await metastoreClient.repository.createMetaObject({
+			objectType: SEMANTIC_OBJECT_TYPE.MODEL,
+			data,
+			branch: DEFAULT_BRANCH,
+			...meta,
+			name: data.name
+		});
+		return mapObject(response.data);
+	};
+	const updateModel = async (modelUUID, data, meta = {}) => {
+		const response = await metastoreClient.repository.updateMetaObject({
+			objectType: SEMANTIC_OBJECT_TYPE.MODEL,
+			UUID: modelUUID,
+			data,
+			...meta,
+			...data.name ? { name: data.name } : {}
+		});
+		return mapObject(response.data);
+	};
+	const listObjects = async (objectType, modelUUID, signal) => {
+		return (await _listObjects(objectType, signal)).filter((object) => object.data.modelUUID === modelUUID);
+	};
+	/**
+	* Find a model's child objects by their user-facing name.
+	*
+	* Returns every match rather than resolving to one, because a name is not unique: the caller
+	* decides whether that's an error (an agent needs an unambiguous target) or a choice to offer
+	* (a UI can render a picker). Glossary entries key on `term`, so both are matched.
+	*/
+	const findObjectsByName = async (objectType, name, modelUUID, signal) => {
+		return (await listObjects(objectType, modelUUID, signal)).filter((object) => deriveOptionalObjectName(object.data) === name);
+	};
+	const createObject = async (objectType, data, meta = {}) => {
+		const response = await metastoreClient.repository.createMetaObject({
+			objectType,
+			data,
+			branch: DEFAULT_BRANCH,
+			...meta,
+			name: deriveObjectName(data)
+		});
+		return mapObject(response.data);
+	};
+	const createObjects = async (objectType, items, meta = {}) => require_concurrent.concurrent({
+		items,
+		process: async (data) => createObject(objectType, data, meta),
+		concurrency: WRITE_CONCURRENCY
+	});
+	const createModelTree = async (model, children, meta = {}) => {
+		const createdModel = await createModel(model, meta);
+		const items = MODEL_CHILD_OBJECT_TYPES.flatMap((objectType) => (children[objectType] ?? []).map((data) => ({
+			objectType,
+			data: {
+				...data,
+				modelUUID: createdModel.uuid
+			}
+		})));
+		return {
+			model: createdModel,
+			children: await require_concurrent.concurrent({
+				items,
+				process: async ({ objectType, data }) => createObject(objectType, data, meta),
+				concurrency: WRITE_CONCURRENCY
+			})
+		};
+	};
+	const updateObject = async (objectType, objectUUID, data, meta = {}) => {
+		const name = deriveOptionalObjectName(data);
+		const response = await metastoreClient.repository.updateMetaObject({
+			objectType,
+			UUID: objectUUID,
+			data,
+			...meta,
+			...name ? { name } : {}
+		});
+		return mapObject(response.data);
+	};
+	const deleteObject = async (objectType, objectUUID) => {
+		await metastoreClient.repository.deleteMetaObject({
+			objectType,
+			UUID: objectUUID
+		});
+	};
+	/**
+	* Every child object of a model, across all five types, flattened.
+	*
+	* `deleteModel` uses this to find what to remove; callers can use it to say what a delete
+	* would destroy *before* asking the user to confirm. Each entry's `name` is the object's
+	* display label (a constraint's `displayName` in preference to its `name`, matching what the
+	* SL tables render), so a confirmation lists objects as the user sees them on screen.
+	*
+	* Costs five list requests: the metastore has no per-model filter, so `listObjects`
+	* fetches each collection and filters client-side.
+	*/
+	const listModelChildren = async (modelUUID, signal) => {
+		return (await Promise.all(MODEL_CHILD_OBJECT_TYPES.map(async (objectType) => {
+			return (await listObjects(objectType, modelUUID, signal)).map((object) => ({
+				objectType,
+				objectUUID: object.uuid,
+				name: deriveObjectLabel(object.data)
+			}));
+		}))).flat();
+	};
+	/**
+	* Cascade delete: every child object first, the model itself only once its whole tree is
+	* gone. Child deletes all settle — a failing child never aborts the others, so no delete
+	* runs on detached after this rejects — and a partial failure surfaces as
+	* `SemanticLayerCascadeDeleteError`, which says exactly which children were deleted and
+	* which survived. The model is kept on any child failure so it never orphans children.
+	*/
+	const deleteModel = async (modelUUID) => {
+		const children = await listModelChildren(modelUUID);
+		const outcomes = await require_concurrent.concurrent({
+			items: children,
+			process: async (child) => {
+				try {
+					await deleteObject(child.objectType, child.objectUUID);
+					return {
+						ok: true,
+						child
+					};
+				} catch (error) {
+					return {
+						ok: false,
+						child,
+						error
+					};
+				}
+			},
+			concurrency: WRITE_CONCURRENCY
+		});
+		const deletedChildren = [];
+		const failedChildren = [];
+		for (const outcome of outcomes) if (outcome.ok) deletedChildren.push(outcome.child);
+		else failedChildren.push({
+			...outcome.child,
+			error: outcome.error
+		});
+		if (failedChildren.length > 0) throw new SemanticLayerCascadeDeleteError({
+			modelUUID,
+			deletedChildren,
+			failedChildren
+		});
+		await metastoreClient.repository.deleteMetaObject({
+			objectType: SEMANTIC_OBJECT_TYPE.MODEL,
+			UUID: modelUUID
+		});
+	};
+	/**
+	* Replace the sibling projects granted GET/consumption access to a `targeted`-scope object.
+	*
+	* Passing an empty array clears every grant, leaving the object visible to its owning project
+	* only. A grant conveys read access alone — the target projects can consume the definition but
+	* never edit it, which is enforced metastore-side rather than here.
+	*/
+	const replaceTargetProjects = async (objectType, objectUUID, targetProjectIds) => {
+		await metastoreClient.repository.replaceTargetProjects({
+			objectType,
+			UUID: objectUUID,
+			targetProjectIds
+		});
+	};
+	/**
+	* Step a project-scoped object up to the organization scope, in place.
+	*
+	* The object keeps its UUID and revision history; the step-up writes a new revision whose
+	* `project_id` is null. Requires the caller to hold the organization-admin role for the target
+	* organization — a project-admin gets 403 from the metastore, which callers should surface
+	* rather than pre-empt (the same person is often both).
+	*/
+	const promoteToOrganizationScope = async (objectType, objectUUID) => {
+		const response = await metastoreClient.repository.updateMetaObject({
+			objectType,
+			UUID: objectUUID,
+			scope: "organization"
+		});
+		return mapObject(response.data);
+	};
+	return {
+		listModels,
+		createModel,
+		updateModel,
+		deleteModel,
+		listModelChildren,
+		listObjects,
+		findObjectsByName,
+		createObject,
+		createObjects,
+		createModelTree,
+		updateObject,
+		deleteObject,
+		replaceTargetProjects,
+		promoteToOrganizationScope
+	};
+};
+//#endregion
+//#region src/sdks/semanticLayer/schemas.ts
+/**
+* Runtime validators for the semantic-layer payload shapes.
+*
+* These exist because the metastore's validation errors are opaque — a missing or misspelled
+* field surfaces only as a generic "Validation failed", and a wrong `sql_dialect` casing as a
+* 422 that names neither the field nor the accepted values. Parsing first turns those into a
+* message that says what is wrong.
+*
+* **Only the fields the SDK types mark as required are declared.** The metastore owns each
+* object type's full schema, so every schema is a `looseObject`: unknown fields pass through
+* untouched rather than being stripped or rejected. Re-declaring the optional fields here
+* would create a second source of truth that silently drops whatever the metastore adds next.
+*
+* The SDK does **not** parse on its own writes — these are for callers that accept untrusted
+* or hand-authored input (an agent's tool call, a form submission) and want to fail early.
+* `modelUUID` is omitted throughout: the SDK injects it, so callers never supply it.
+*/
+const semanticModelSchema = zod.z.looseObject({
+	name: zod.z.string().min(1),
+	sql_dialect: zod.z.enum(SQL_DIALECTS)
 });
-Object.defineProperty(exports, "SQL_DIALECTS", {
-  enumerable: true,
-  get: function () { return chunkG3JHVIDZ_cjs.SQL_DIALECTS; }
+const semanticDatasetSchema = zod.z.looseObject({
+	name: zod.z.string().min(1),
+	tableId: zod.z.string().min(1),
+	fqn: zod.z.string().min(1)
 });
-Object.defineProperty(exports, "SemanticLayerCascadeDeleteError", {
-  enumerable: true,
-  get: function () { return chunkG3JHVIDZ_cjs.SemanticLayerCascadeDeleteError; }
+const semanticMetricSchema = zod.z.looseObject({
+	name: zod.z.string().min(1),
+	sql: zod.z.string().min(1)
 });
-Object.defineProperty(exports, "createSemanticLayerSdk", {
-  enumerable: true,
-  get: function () { return chunkG3JHVIDZ_cjs.createSemanticLayerSdk; }
+const semanticRelationshipSchema = zod.z.looseObject({
+	from: zod.z.string().min(1),
+	to: zod.z.string().min(1),
+	on: zod.z.string().min(1)
 });
-Object.defineProperty(exports, "semanticConstraintSchema", {
-  enumerable: true,
-  get: function () { return chunkG3JHVIDZ_cjs.semanticConstraintSchema; }
+const semanticGlossarySchema = zod.z.looseObject({
+	term: zod.z.string().min(1),
+	definition: zod.z.string().min(1)
 });
-Object.defineProperty(exports, "semanticDatasetSchema", {
-  enumerable: true,
-  get: function () { return chunkG3JHVIDZ_cjs.semanticDatasetSchema; }
+const semanticConstraintSchema = zod.z.looseObject({
+	name: zod.z.string().min(1),
+	constraintType: zod.z.enum(CONSTRAINT_TYPES),
+	metrics: zod.z.array(zod.z.string()),
+	rule: zod.z.string().min(1)
 });
-Object.defineProperty(exports, "semanticGlossarySchema", {
-  enumerable: true,
-  get: function () { return chunkG3JHVIDZ_cjs.semanticGlossarySchema; }
-});
-Object.defineProperty(exports, "semanticMetricSchema", {
-  enumerable: true,
-  get: function () { return chunkG3JHVIDZ_cjs.semanticMetricSchema; }
-});
-Object.defineProperty(exports, "semanticModelSchema", {
-  enumerable: true,
-  get: function () { return chunkG3JHVIDZ_cjs.semanticModelSchema; }
-});
-Object.defineProperty(exports, "semanticRelationshipSchema", {
-  enumerable: true,
-  get: function () { return chunkG3JHVIDZ_cjs.semanticRelationshipSchema; }
-});
-//# sourceMappingURL=index.cjs.map
+/** Keyed by object type so a caller can pick the schema from a `SemanticChildObjectType`. */
+const SEMANTIC_CHILD_OBJECT_SCHEMAS = {
+	"semantic-dataset": semanticDatasetSchema,
+	"semantic-metric": semanticMetricSchema,
+	"semantic-relationship": semanticRelationshipSchema,
+	"semantic-glossary": semanticGlossarySchema,
+	"semantic-constraint": semanticConstraintSchema
+};
+//#endregion
+exports.CONSTRAINT_TYPES = CONSTRAINT_TYPES;
+exports.MODEL_CHILD_OBJECT_TYPES = MODEL_CHILD_OBJECT_TYPES;
+exports.SEMANTIC_CHILD_OBJECT_SCHEMAS = SEMANTIC_CHILD_OBJECT_SCHEMAS;
+exports.SEMANTIC_OBJECT_TYPE = SEMANTIC_OBJECT_TYPE;
+exports.SQL_DIALECTS = SQL_DIALECTS;
+exports.SemanticLayerCascadeDeleteError = SemanticLayerCascadeDeleteError;
+exports.createSemanticLayerSdk = createSemanticLayerSdk;
+exports.semanticConstraintSchema = semanticConstraintSchema;
+exports.semanticDatasetSchema = semanticDatasetSchema;
+exports.semanticGlossarySchema = semanticGlossarySchema;
+exports.semanticMetricSchema = semanticMetricSchema;
+exports.semanticModelSchema = semanticModelSchema;
+exports.semanticRelationshipSchema = semanticRelationshipSchema;
+
 //# sourceMappingURL=index.cjs.map

package/dist/sdk/semanticLayer/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"index.cjs"}
+{"version":3,"file":"index.cjs","names":["generateUUID","concurrent","z"],"sources":["../../../src/sdks/semanticLayer/semanticLayerSdk.ts","../../../src/sdks/semanticLayer/schemas.ts"],"sourcesContent":["import { concurrent, generateUUID } from '../../utils';\n\nimport type {\n  CreateSemanticObjectMeta,\n  MetastoreClient,\n  SemanticChildObjectDataMap,\n  SemanticChildObjectType,\n  SemanticConstraintType,\n  SemanticModelChildDeleteFailure,\n  SemanticModelChildRef,\n  SemanticModelData,\n  SemanticObject,\n  SemanticObjectMeta,\n  SemanticObjectType,\n  UpdateSemanticObjectMeta,\n} from './types';\n\n/**\n * Thrown by `deleteModel` when the child cascade partially fails. Every child delete has\n * settled by the time this is thrown — nothing keeps deleting in the background — and the\n * model itself was kept, so the exact remaining state is knowable: `deletedChildren` are gone,\n * `failedChildren` (and the model) still exist. `errors` carries the per-child rejection\n * reasons, AggregateError-style.\n */\nexport class SemanticLayerCascadeDeleteError extends AggregateError {\n  readonly modelUUID: string;\n  readonly deletedChildren: SemanticModelChildRef[];\n  readonly failedChildren: SemanticModelChildDeleteFailure[];\n\n  constructor({\n    modelUUID,\n    deletedChildren,\n    failedChildren,\n  }: {\n    modelUUID: string;\n    deletedChildren: SemanticModelChildRef[];\n    failedChildren: SemanticModelChildDeleteFailure[];\n  }) {\n    const total = deletedChildren.length + failedChildren.length;\n    super(\n      failedChildren.map((failure) => failure.error),\n      `The model was kept because ${failedChildren.length} of its ${total} child objects ` +\n        `could not be deleted (${deletedChildren.length} deleted).`,\n    );\n    this.name = 'SemanticLayerCascadeDeleteError';\n    this.modelUUID = modelUUID;\n    this.deletedChildren = deletedChildren;\n    this.failedChildren = failedChildren;\n  }\n}\n\nexport const SEMANTIC_OBJECT_TYPE = {\n  MODEL: 'semantic-model',\n  DATASET: 'semantic-dataset',\n  METRIC: 'semantic-metric',\n  RELATIONSHIP: 'semantic-relationship',\n  GLOSSARY: 'semantic-glossary',\n  CONSTRAINT: 'semantic-constraint',\n} as const satisfies Record<string, SemanticObjectType>;\n\n/**\n * `readonly` because this drives `createModelTree`, `listModelChildren` and `deleteModel` —\n * a consumer-side `.push()` would silently change what a cascade delete touches.\n */\nexport const MODEL_CHILD_OBJECT_TYPES: readonly SemanticChildObjectType[] = [\n  SEMANTIC_OBJECT_TYPE.DATASET,\n  SEMANTIC_OBJECT_TYPE.METRIC,\n  SEMANTIC_OBJECT_TYPE.RELATIONSHIP,\n  SEMANTIC_OBJECT_TYPE.GLOSSARY,\n  SEMANTIC_OBJECT_TYPE.CONSTRAINT,\n] as const;\n\n/**\n * The dialects the metastore accepts, exactly as it spells them. A lowercase value is\n * rejected with `422 value must be one of 'Snowflake', 'BigQuery'`, which surfaces only as a\n * generic \"Validation failed\" — so callers need the real set rather than a bare `string`.\n *\n * `SemanticModelData.sql_dialect` stays `string` for now: narrowing it would break any caller\n * passing a `string` variable, which is a major bump. Validate against this instead.\n */\nexport const SQL_DIALECTS = ['Snowflake', 'BigQuery'] as const;\n\n/** The metastore's constraint kinds. Runtime counterpart to `SemanticConstraintType`. */\nexport const CONSTRAINT_TYPES = [\n  'inequality',\n  'equality',\n  'range',\n  'composition',\n  'exclusion',\n  'temporal',\n  'conditional',\n] as const satisfies readonly SemanticConstraintType[];\n\nconst DEFAULT_BRANCH = 'main';\n\n// The metastore has no bulk endpoint; large semantic-layer inits are written as\n// concurrent single POSTs (the same approach the ai-kit sl-toolkit importer uses).\nconst WRITE_CONCURRENCY = 5;\n\n// The live metastore envelope: `attributes` carries the object's data payload directly,\n// the UUID is the top-level `id`, and revision/branch/audit fields live in `meta`. The\n// legacy wrapper types in clients/metastore/repository/types.ts do not match this shape.\ntype RawSemanticObject<TData> = {\n  type: string;\n  id: string;\n  attributes: TData;\n  meta: SemanticObjectMeta;\n};\n\nconst mapObject = <TData>(item: RawSemanticObject<TData>): SemanticObject<TData> => ({\n  uuid: item.id,\n  data: item.attributes,\n  meta: item.meta,\n});\n\nconst deriveOptionalObjectName = (data: Record<string, unknown>): string | undefined => {\n  if (typeof data.name === 'string') return data.name;\n  if (typeof data.term === 'string') return data.term;\n  return undefined;\n};\n\nconst deriveObjectName = (data: Record<string, unknown>) =>\n  deriveOptionalObjectName(data) ?? generateUUID();\n\n/**\n * The label a UI shows for an object, as opposed to the identifier it is addressed by.\n *\n * Constraints carry an optional `displayName`; kbc-ui's constraint tables already render\n * `displayName ?? name`, so a confirmation listing what a cascade delete would destroy has to\n * agree with them or it names objects the user can't find on screen.\n *\n * Deliberately **not** used for lookup: `displayName` is optional and not unique, so matching on\n * it would make `findObjectsByName` ambiguous for callers that resolve a write target by name.\n */\nconst deriveObjectLabel = (data: Record<string, unknown>): string | undefined => {\n  if (typeof data.displayName === 'string' && data.displayName !== '') return data.displayName;\n  return deriveOptionalObjectName(data);\n};\n\ntype Options = {\n  metastoreClient: MetastoreClient;\n};\n\nexport const createSemanticLayerSdk = ({ metastoreClient }: Options) => {\n  const _listObjects = async <TData extends Record<string, unknown>>(\n    objectType: SemanticObjectType,\n    signal?: AbortSignal,\n  ) => {\n    const response = await metastoreClient.repository.getMetaObjects<TData>({ objectType }, signal);\n    return (response.data as unknown as RawSemanticObject<TData>[]).map(mapObject);\n  };\n\n  const listModels = async (signal?: AbortSignal) =>\n    _listObjects<SemanticModelData>(SEMANTIC_OBJECT_TYPE.MODEL, signal);\n\n  const createModel = async (data: SemanticModelData, meta: CreateSemanticObjectMeta = {}) => {\n    const response = await metastoreClient.repository.createMetaObject<SemanticModelData>({\n      objectType: SEMANTIC_OBJECT_TYPE.MODEL,\n      data,\n      branch: DEFAULT_BRANCH,\n      ...meta,\n      // Derived name wins over meta so the metastore name stays in sync with the payload.\n      name: data.name,\n    });\n\n    return mapObject(response.data as unknown as RawSemanticObject<SemanticModelData>);\n  };\n\n  const updateModel = async (\n    modelUUID: string,\n    data: Partial<SemanticModelData>,\n    meta: UpdateSemanticObjectMeta = {},\n  ) => {\n    const response = await metastoreClient.repository.updateMetaObject<SemanticModelData>({\n      objectType: SEMANTIC_OBJECT_TYPE.MODEL,\n      UUID: modelUUID,\n      data,\n      ...meta,\n      // Derived rename wins over meta so the metastore name stays in sync with the payload.\n      ...(data.name ? { name: data.name } : {}),\n    });\n\n    return mapObject(response.data as unknown as RawSemanticObject<SemanticModelData>);\n  };\n\n  const listObjects = async <T extends SemanticChildObjectType>(\n    objectType: T,\n    modelUUID: string,\n    signal?: AbortSignal,\n  ) => {\n    const objects = await _listObjects<SemanticChildObjectDataMap[T]>(objectType, signal);\n    return objects.filter((object) => object.data.modelUUID === modelUUID);\n  };\n\n  /**\n   * Find a model's child objects by their user-facing name.\n   *\n   * Returns every match rather than resolving to one, because a name is not unique: the caller\n   * decides whether that's an error (an agent needs an unambiguous target) or a choice to offer\n   * (a UI can render a picker). Glossary entries key on `term`, so both are matched.\n   */\n  const findObjectsByName = async <T extends SemanticChildObjectType>(\n    objectType: T,\n    name: string,\n    modelUUID: string,\n    signal?: AbortSignal,\n  ) => {\n    const objects = await listObjects(objectType, modelUUID, signal);\n    return objects.filter((object) => deriveOptionalObjectName(object.data) === name);\n  };\n\n  const createObject = async <T extends SemanticChildObjectType>(\n    objectType: T,\n    data: SemanticChildObjectDataMap[T],\n    meta: CreateSemanticObjectMeta = {},\n  ) => {\n    const response = await metastoreClient.repository.createMetaObject<\n      SemanticChildObjectDataMap[T]\n    >({\n      objectType,\n      data,\n      branch: DEFAULT_BRANCH,\n      ...meta,\n      // Derived name wins over meta so the metastore name stays in sync with the payload.\n      name: deriveObjectName(data),\n    });\n\n    return mapObject(response.data as unknown as RawSemanticObject<SemanticChildObjectDataMap[T]>);\n  };\n\n  const createObjects = async <T extends SemanticChildObjectType>(\n    objectType: T,\n    items: SemanticChildObjectDataMap[T][],\n    meta: CreateSemanticObjectMeta = {},\n  ) =>\n    concurrent({\n      items,\n      process: async (data) => createObject(objectType, data, meta),\n      concurrency: WRITE_CONCURRENCY,\n    });\n\n  // Create a model and all its child objects in one call: the model first (so its\n  // UUID exists), then every child concurrently with the modelUUID injected.\n  const createModelTree = async (\n    model: SemanticModelData,\n    children: Partial<{\n      [T in SemanticChildObjectType]: Omit<SemanticChildObjectDataMap[T], 'modelUUID'>[];\n    }>,\n    meta: CreateSemanticObjectMeta = {},\n  ) => {\n    const createdModel = await createModel(model, meta);\n\n    const items = MODEL_CHILD_OBJECT_TYPES.flatMap((objectType) =>\n      (children[objectType] ?? []).map((data) => ({\n        objectType,\n        data: {\n          ...data,\n          modelUUID: createdModel.uuid,\n        } satisfies SemanticChildObjectDataMap[typeof objectType],\n      })),\n    );\n\n    const createdChildren = await concurrent({\n      items,\n      process: async ({ objectType, data }) => createObject(objectType, data, meta),\n      concurrency: WRITE_CONCURRENCY,\n    });\n\n    return { model: createdModel, children: createdChildren };\n  };\n\n  const updateObject = async <T extends SemanticChildObjectType>(\n    objectType: T,\n    objectUUID: string,\n    data: Partial<SemanticChildObjectDataMap[T]>,\n    meta: UpdateSemanticObjectMeta = {},\n  ) => {\n    const name = deriveOptionalObjectName(data);\n    const response = await metastoreClient.repository.updateMetaObject<\n      SemanticChildObjectDataMap[T]\n    >({\n      objectType,\n      UUID: objectUUID,\n      data,\n      ...meta,\n      // Derived rename wins over meta so the metastore name stays in sync with the payload.\n      ...(name ? { name } : {}),\n    });\n\n    return mapObject(response.data as unknown as RawSemanticObject<SemanticChildObjectDataMap[T]>);\n  };\n\n  const deleteObject = async (objectType: SemanticChildObjectType, objectUUID: string) => {\n    await metastoreClient.repository.deleteMetaObject({\n      objectType,\n      UUID: objectUUID,\n    });\n  };\n\n  /**\n   * Every child object of a model, across all five types, flattened.\n   *\n   * `deleteModel` uses this to find what to remove; callers can use it to say what a delete\n   * would destroy *before* asking the user to confirm. Each entry's `name` is the object's\n   * display label (a constraint's `displayName` in preference to its `name`, matching what the\n   * SL tables render), so a confirmation lists objects as the user sees them on screen.\n   *\n   * Costs five list requests: the metastore has no per-model filter, so `listObjects`\n   * fetches each collection and filters client-side.\n   */\n  const listModelChildren = async (\n    modelUUID: string,\n    signal?: AbortSignal,\n  ): Promise<SemanticModelChildRef[]> => {\n    const childrenByType = await Promise.all(\n      MODEL_CHILD_OBJECT_TYPES.map(async (objectType) => {\n        const objects = await listObjects(objectType, modelUUID, signal);\n        return objects.map((object) => ({\n          objectType,\n          objectUUID: object.uuid,\n          name: deriveObjectLabel(object.data),\n        }));\n      }),\n    );\n\n    return childrenByType.flat();\n  };\n\n  /**\n   * Cascade delete: every child object first, the model itself only once its whole tree is\n   * gone. Child deletes all settle — a failing child never aborts the others, so no delete\n   * runs on detached after this rejects — and a partial failure surfaces as\n   * `SemanticLayerCascadeDeleteError`, which says exactly which children were deleted and\n   * which survived. The model is kept on any child failure so it never orphans children.\n   */\n  const deleteModel = async (modelUUID: string) => {\n    const children = await listModelChildren(modelUUID);\n\n    const outcomes = await concurrent({\n      items: children,\n      process: async (child) => {\n        try {\n          await deleteObject(child.objectType, child.objectUUID);\n          return { ok: true as const, child };\n        } catch (error) {\n          return { ok: false as const, child, error };\n        }\n      },\n      concurrency: WRITE_CONCURRENCY,\n    });\n\n    const deletedChildren: SemanticModelChildRef[] = [];\n    const failedChildren: SemanticModelChildDeleteFailure[] = [];\n    for (const outcome of outcomes) {\n      if (outcome.ok) deletedChildren.push(outcome.child);\n      else failedChildren.push({ ...outcome.child, error: outcome.error });\n    }\n\n    if (failedChildren.length > 0) {\n      throw new SemanticLayerCascadeDeleteError({ modelUUID, deletedChildren, failedChildren });\n    }\n\n    await metastoreClient.repository.deleteMetaObject({\n      objectType: SEMANTIC_OBJECT_TYPE.MODEL,\n      UUID: modelUUID,\n    });\n  };\n\n  /**\n   * Replace the sibling projects granted GET/consumption access to a `targeted`-scope object.\n   *\n   * Passing an empty array clears every grant, leaving the object visible to its owning project\n   * only. A grant conveys read access alone — the target projects can consume the definition but\n   * never edit it, which is enforced metastore-side rather than here.\n   */\n  const replaceTargetProjects = async (\n    objectType: SemanticObjectType,\n    objectUUID: string,\n    targetProjectIds: number[],\n  ) => {\n    await metastoreClient.repository.replaceTargetProjects({\n      objectType,\n      UUID: objectUUID,\n      targetProjectIds,\n    });\n  };\n\n  /**\n   * Step a project-scoped object up to the organization scope, in place.\n   *\n   * The object keeps its UUID and revision history; the step-up writes a new revision whose\n   * `project_id` is null. Requires the caller to hold the organization-admin role for the target\n   * organization — a project-admin gets 403 from the metastore, which callers should surface\n   * rather than pre-empt (the same person is often both).\n   */\n  const promoteToOrganizationScope = async (objectType: SemanticObjectType, objectUUID: string) => {\n    // Scope ONLY. No `data`, not even `{}`: the metastore's step-up guard rejects a PATCH that\n    // also carries name or data, and `Data *JSONData` treats `{}` as present — which 400s with\n    // \"A scope change cannot be combined with name or data changes\".\n    const response = await metastoreClient.repository.updateMetaObject({\n      objectType,\n      UUID: objectUUID,\n      scope: 'organization',\n    });\n\n    return mapObject(response.data as unknown as RawSemanticObject<Record<string, unknown>>);\n  };\n\n  return {\n    // models\n    listModels,\n    createModel,\n    updateModel,\n    deleteModel,\n    listModelChildren,\n\n    // child objects (datasets, metrics, relationships, glossary, constraints)\n    listObjects,\n    findObjectsByName,\n    createObject,\n    createObjects,\n    createModelTree,\n    updateObject,\n    deleteObject,\n\n    // scoping / sharing\n    replaceTargetProjects,\n    promoteToOrganizationScope,\n  };\n};\n","import { z } from 'zod';\n\nimport { CONSTRAINT_TYPES, SQL_DIALECTS } from './semanticLayerSdk';\n\n/**\n * Runtime validators for the semantic-layer payload shapes.\n *\n * These exist because the metastore's validation errors are opaque — a missing or misspelled\n * field surfaces only as a generic \"Validation failed\", and a wrong `sql_dialect` casing as a\n * 422 that names neither the field nor the accepted values. Parsing first turns those into a\n * message that says what is wrong.\n *\n * **Only the fields the SDK types mark as required are declared.** The metastore owns each\n * object type's full schema, so every schema is a `looseObject`: unknown fields pass through\n * untouched rather than being stripped or rejected. Re-declaring the optional fields here\n * would create a second source of truth that silently drops whatever the metastore adds next.\n *\n * The SDK does **not** parse on its own writes — these are for callers that accept untrusted\n * or hand-authored input (an agent's tool call, a form submission) and want to fail early.\n * `modelUUID` is omitted throughout: the SDK injects it, so callers never supply it.\n */\n\nexport const semanticModelSchema = z.looseObject({\n  name: z.string().min(1),\n  sql_dialect: z.enum(SQL_DIALECTS),\n});\n\nexport const semanticDatasetSchema = z.looseObject({\n  name: z.string().min(1),\n  tableId: z.string().min(1),\n  fqn: z.string().min(1),\n});\n\nexport const semanticMetricSchema = z.looseObject({\n  name: z.string().min(1),\n  sql: z.string().min(1),\n});\n\nexport const semanticRelationshipSchema = z.looseObject({\n  from: z.string().min(1),\n  to: z.string().min(1),\n  on: z.string().min(1),\n});\n\nexport const semanticGlossarySchema = z.looseObject({\n  term: z.string().min(1),\n  definition: z.string().min(1),\n});\n\nexport const semanticConstraintSchema = z.looseObject({\n  name: z.string().min(1),\n  constraintType: z.enum(CONSTRAINT_TYPES),\n  metrics: z.array(z.string()),\n  rule: z.string().min(1),\n});\n\n/** Keyed by object type so a caller can pick the schema from a `SemanticChildObjectType`. */\nexport const SEMANTIC_CHILD_OBJECT_SCHEMAS = {\n  'semantic-dataset': semanticDatasetSchema,\n  'semantic-metric': semanticMetricSchema,\n  'semantic-relationship': semanticRelationshipSchema,\n  'semantic-glossary': semanticGlossarySchema,\n  'semantic-constraint': semanticConstraintSchema,\n} as const;\n"],"mappings":"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"}