@keboola/api-client 32.0.0 → 34.0.0

package/dist/semanticLayer-CSqmtHRo.js

@@ -0,0 +1,692 @@
+import { t as concurrent } from "./concurrent-CH9fbNr3.js";
+import { t as generateUUID } from "./generateUUID-Dr8l-aoc.js";
+import { i as parseOrThrow, n as formatValidationIssues } from "./ValidationError-BekhphAq.js";
+import { z } from "zod";
+//#region src/sdks/semanticLayer/errorMessage.ts
+/**
+* The message out of a metastore error body.
+*
+* - The metastore reports what is actually wrong with a write only inside `errors[].message`
+*   (`missing property 'fqn'`). The HTTP status and the response's own message say no more than
+*   "Validation failed", so a caller that renders those alone tells a user nothing actionable.
+* - Every shape that is not that envelope returns `undefined` rather than a placeholder, so the
+*   caller keeps its own fallback (`?? error.message`) instead of rendering a stand-in for one.
+* - Only the first error: the metastore reports fields one at a time, so a list would be a list
+*   of one.
+*/
+const metastoreErrorMessage = (data) => {
+	if (typeof data !== "object" || data === null) return void 0;
+	const errors = data.errors;
+	if (!Array.isArray(errors)) return void 0;
+	const first = errors[0];
+	if (typeof first !== "object" || first === null) return void 0;
+	const message = first.message;
+	return typeof message === "string" && message ? message : void 0;
+};
+//#endregion
+//#region src/sdks/semanticLayer/vocabulary.ts
+/**
+* The closed value sets the metastore accepts inside a semantic object's `data`.
+*
+* - Each one is the single runtime source for a union in `./types`, which derives the type from
+*   the array here. A value cannot exist in the type and be missing from the list a dropdown or
+*   a validator is built from.
+* - The addressing vocabulary (`SEMANTIC_OBJECT_TYPE`, `MODEL_CHILD_OBJECT_TYPES`) is a
+*   different axis — which object a call targets, not what may sit inside one — and stays beside
+*   the SDK methods that take it.
+* - This file imports nothing: `./types` reads it, never the reverse.
+*/
+/**
+* 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. */
+const CONSTRAINT_TYPES = [
+	"inequality",
+	"equality",
+	"range",
+	"composition",
+	"exclusion",
+	"temporal",
+	"conditional"
+];
+/**
+* What a dataset field is for.
+*
+* - Enumerated, unlike a field's `type`: the metastore takes any type string, but only these
+*   four roles.
+*/
+const FIELD_ROLES = [
+	"key",
+	"dimension",
+	"measure",
+	"timestamp"
+];
+/**
+* How loudly a violated constraint reports.
+*
+* - An unset severity is stored as `warning`, so a reader renders that rather than nothing.
+*/
+const CONSTRAINT_SEVERITIES = [
+	"error",
+	"warning",
+	"info"
+];
+/**
+* What a constraint's rule is evaluated per.
+*
+* - An unset scope is stored as `global`.
+*/
+const CONSTRAINT_SCOPES = [
+	"global",
+	"per_location",
+	"per_date",
+	"per_category"
+];
+/** The comparisons a constraint's `ruleExpression` can make. */
+const RULE_OPERATORS = [
+	"<",
+	"<=",
+	"=",
+	">=",
+	">",
+	"!=",
+	"between",
+	"in",
+	"sum_equals",
+	"ratio_between"
+];
+/** The join a relationship stands for. */
+const RELATIONSHIP_JOIN_TYPES = ["left", "inner"];
+//#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 = z.looseObject({
+	name: z.string().min(1),
+	sql_dialect: z.enum(SQL_DIALECTS)
+});
+const semanticDatasetSchema = z.looseObject({
+	name: z.string().min(1),
+	tableId: z.string().min(1),
+	fqn: z.string().min(1)
+});
+const semanticMetricSchema = z.looseObject({
+	name: z.string().min(1),
+	sql: z.string().min(1)
+});
+const semanticRelationshipSchema = z.looseObject({
+	from: z.string().min(1),
+	to: z.string().min(1),
+	on: z.string().min(1)
+});
+const semanticGlossarySchema = z.looseObject({
+	term: z.string().min(1),
+	definition: z.string().min(1)
+});
+const semanticConstraintSchema = z.looseObject({
+	name: z.string().min(1),
+	constraintType: z.enum(CONSTRAINT_TYPES),
+	metrics: z.array(z.string()),
+	rule: z.string().min(1)
+});
+/** 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
+//#region src/sdks/semanticLayer/readSchemas.ts
+/**
+* What a read of the metastore is allowed to hand back, per object type.
+*
+* - Every schema is annotated with the type it must produce, so the compiler rejects a schema that
+*   omits a field `./types` declares or makes a required one optional. The declared type and the
+*   parser cannot drift apart.
+* - `looseObject` throughout: a field the metastore adds still reaches a caller at runtime, exactly
+*   as it did when this boundary asserted instead of parsing.
+* - The metastore validates each object type on write — that is where its opaque "Validation
+*   failed" and `sql_dialect` 422s come from — so a stored object already satisfies these. Parsing
+*   is the net under that, for an object written before a schema version tightened and for the
+*   day the two schemas disagree.
+* - An **optional** enum that arrives with a value outside the list reads as absent rather than
+*   taking its object down: a new `role` the metastore starts issuing must not delete the dataset
+*   carrying it. A **required** enum has no such reading — `constraintType` decides what a
+*   constraint means — so an unknown value drops the object.
+*/
+const aiMetadataSchema = z.looseObject({
+	synonyms: z.array(z.string()).optional(),
+	keywords: z.array(z.string()).optional(),
+	antiKeywords: z.array(z.string()).optional(),
+	hints: z.array(z.string()).optional(),
+	warnings: z.array(z.string()).optional()
+});
+const fieldSchema = z.looseObject({
+	name: z.string(),
+	description: z.string().optional(),
+	type: z.string().optional(),
+	role: z.enum(FIELD_ROLES).optional().catch(void 0),
+	values: z.array(z.string()).optional(),
+	ai: aiMetadataSchema.optional()
+});
+/**
+* A dataset's `fields`, where a malformed column is dropped rather than the whole dataset.
+*
+* - `name` is required and `schemas.ts` does not validate `fields` on write, so this SDK can
+*   store a nameless column that a strict read would then hide the entire table over.
+* - The same rule as the collection one level up: a drop never takes its container with it.
+*/
+const datasetFieldsSchema = z.array(z.unknown()).transform((items) => items.flatMap((element, index) => {
+	const result = fieldSchema.safeParse(element);
+	if (result.success) return [result.data];
+	console.warn(`semanticLayerSdk: dropped field #${index} from a semantic-dataset, it does not match its declared shape`, formatValidationIssues(result.error.issues));
+	return [];
+}));
+const ruleExpressionSchema = z.looseObject({
+	operator: z.enum(RULE_OPERATORS).optional().catch(void 0),
+	left: z.string().optional(),
+	right: z.string().optional(),
+	bounds: z.looseObject({
+		min: z.number().optional(),
+		max: z.number().optional()
+	}).optional()
+});
+const validationQuerySchema = z.looseObject({
+	default: z.string().optional(),
+	snowflake: z.string().optional(),
+	bigquery: z.string().optional()
+});
+const semanticModelReadSchema = z.looseObject({
+	name: z.string(),
+	description: z.string().optional(),
+	sql_dialect: z.string()
+});
+/** Keyed by object type so a read can pick the schema from a `SemanticChildObjectType`. */
+const SEMANTIC_CHILD_OBJECT_READ_SCHEMAS = {
+	"semantic-dataset": z.looseObject({
+		modelUUID: z.string(),
+		name: z.string(),
+		tableId: z.string(),
+		fqn: z.string(),
+		description: z.string().optional(),
+		grain: z.string().optional(),
+		primaryKey: z.array(z.string()).optional(),
+		fields: datasetFieldsSchema.optional(),
+		ai: aiMetadataSchema.optional()
+	}),
+	"semantic-metric": z.looseObject({
+		modelUUID: z.string(),
+		name: z.string(),
+		sql: z.string(),
+		dataset: z.string().optional(),
+		description: z.string().optional()
+	}),
+	"semantic-relationship": z.looseObject({
+		modelUUID: z.string(),
+		name: z.string().optional(),
+		from: z.string(),
+		to: z.string(),
+		on: z.string(),
+		type: z.enum(RELATIONSHIP_JOIN_TYPES).optional().catch(void 0)
+	}),
+	"semantic-glossary": z.looseObject({
+		modelUUID: z.string(),
+		term: z.string(),
+		definition: z.string(),
+		seeAlso: z.array(z.string()).optional()
+	}),
+	"semantic-constraint": z.looseObject({
+		modelUUID: z.string(),
+		name: z.string(),
+		displayName: z.string().optional(),
+		description: z.string().optional(),
+		constraintType: z.enum(CONSTRAINT_TYPES),
+		metrics: z.array(z.string()),
+		datasets: z.array(z.string()).optional(),
+		rule: z.string(),
+		ruleExpression: ruleExpressionSchema.optional(),
+		validationQuery: validationQuerySchema.optional(),
+		severity: z.enum(CONSTRAINT_SEVERITIES).optional().catch(void 0),
+		errorMessage: z.string().optional(),
+		remediation: z.string().optional(),
+		isActive: z.boolean().optional(),
+		scope: z.enum(CONSTRAINT_SCOPES).optional().catch(void 0),
+		owner: z.string().optional(),
+		tags: z.array(z.string()).optional()
+	})
+};
+const semanticObjectMetaSchema = z.looseObject({
+	name: z.string().optional(),
+	branch: z.string().optional(),
+	projectId: z.number().optional(),
+	organizationId: z.string().optional(),
+	revision: z.number().optional(),
+	schemaVersion: z.string().optional(),
+	createdAt: z.string().optional(),
+	lastUpdated: z.string().optional(),
+	revisionCreatedAt: z.string().optional()
+});
+/**
+* The envelope every read comes wrapped in, mapped to the `SemanticObject` the SDK returns.
+*
+* `meta` is absent on nothing we have seen, but every field inside it is optional, so an envelope
+* that omits it is a normalization rather than a failure — the alternative is dropping an object
+* over audit fields no caller requires. `null` normalizes the same way: a serializer that writes
+* an absent object as `null` must not be a different outcome from one that omits the key.
+*/
+const semanticObjectReadSchema = (dataSchema) => z.object({
+	id: z.string(),
+	attributes: dataSchema,
+	meta: semanticObjectMetaSchema.nullish()
+}).transform(({ id, attributes, meta }) => ({
+	uuid: id,
+	data: attributes,
+	meta: meta ?? {}
+}));
+//#endregion
+//#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;
+	}
+};
+/**
+* Thrown by `listModelChildren` when a read that has to be complete was not.
+*
+* - A dropped object is invisible to the caller, and two of this SDK's answers cannot survive
+*   that: what a delete would destroy, and whether a model still has children.
+* - So this one read fails closed where a display read degrades. `deleteModel` calls it before
+*   the cascade starts, so nothing is deleted when it throws.
+* - `unreadable` lists what could not be parsed. `modelUUID` is `null` when that field is itself
+*   part of what failed — an object that cannot name its model is counted against every model,
+*   because the alternative is deleting the model it turns out to belong to.
+*/
+var SemanticLayerUnreadableChildrenError = class extends Error {
+	modelUUID;
+	unreadable;
+	constructor({ modelUUID, unreadable }) {
+		super(`${unreadable.length} child object(s) of the model could not be read, so what it holds is unknown and nothing was deleted.`);
+		this.name = "SemanticLayerUnreadableChildrenError";
+		this.modelUUID = modelUUID;
+		this.unreadable = unreadable;
+	}
+};
+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
+];
+const DEFAULT_BRANCH = "main";
+const WRITE_CONCURRENCY = 5;
+const mapObject = (item) => ({
+	uuid: item.id,
+	data: item.attributes,
+	meta: item.meta
+});
+/**
+* The UUID of an envelope that failed to parse, read off the raw value.
+*
+* There is no parse result to read it from. `null` — no `id`, not a string, or not an object at
+* all — means the object is unaddressable: nothing can fetch, fix or delete it by UUID.
+*/
+const envelopeId = (value) => {
+	if (typeof value !== "object" || value === null) return null;
+	const { id } = value;
+	return typeof id === "string" && id !== "" ? id : null;
+};
+/**
+* The model a *dropped* envelope claims, read off the raw value.
+*
+* `listObjects` scopes a collection by the parsed `data.modelUUID`, which an object that failed
+* to parse has none of. `null` — the field is missing, not a string, or the envelope is not an
+* object — means "cannot be attributed", and every caller here treats that as "could be this
+* model's".
+*/
+const envelopeModelUUID = (value) => {
+	if (typeof value !== "object" || value === null) return null;
+	const { attributes } = value;
+	if (typeof attributes !== "object" || attributes === null) return null;
+	const { modelUUID } = attributes;
+	return typeof modelUUID === "string" && modelUUID !== "" ? modelUUID : null;
+};
+const deriveOptionalObjectName = (data) => {
+	if (typeof data.name === "string") return data.name;
+	if (typeof data.term === "string") return data.term;
+};
+const deriveObjectName = (data) => deriveOptionalObjectName(data) ?? 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 }) => {
+	/**
+	* Every object of one type, parsed rather than asserted.
+	*
+	* - Each element is validated against the shape `./types` declares for it, so a caller that
+	*   reads a field the type marks required gets a string and not a `TypeError` in render.
+	* - An element that does not match is dropped and the reason logged — the metastore validates
+	*   these on write, so one that fails here is genuinely broken, and a half-formed object is
+	*   worse to hand a caller than no object.
+	* - A drop never takes the collection with it: a model with one malformed metric still lists
+	*   the other nine.
+	* - A response that is not a collection at all is a different failure and throws, because
+	*   reading it as an empty list would render "this project has no metrics".
+	*/
+	const _listObjects = async (objectType, dataSchema, signal) => {
+		const response = await metastoreClient.repository.getMetaObjects({ objectType }, signal);
+		const items = parseOrThrow(z.array(z.unknown()), response.data);
+		const schema = semanticObjectReadSchema(dataSchema);
+		const objects = [];
+		const unreadable = [];
+		for (const item of items) {
+			const result = schema.safeParse(item);
+			if (result.success) {
+				objects.push(result.data);
+				continue;
+			}
+			unreadable.push({
+				objectType,
+				objectUUID: envelopeId(item),
+				modelUUID: envelopeModelUUID(item)
+			});
+			console.warn(`semanticLayerSdk: dropped ${objectType} "${envelopeId(item) ?? "<no id>"}" from the metastore response, it does not match its declared shape`, formatValidationIssues(result.error.issues));
+		}
+		return {
+			objects,
+			unreadable
+		};
+	};
+	const listModels = async (signal) => (await _listObjects(SEMANTIC_OBJECT_TYPE.MODEL, semanticModelReadSchema, signal)).objects;
+	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);
+	};
+	/**
+	* One child collection, scoped to a model, with what the scoping could not account for.
+	*
+	* - An object that parsed is this model's when its `modelUUID` matches.
+	* - An object that did not parse is this model's when the raw envelope says so — and also when
+	*   the envelope cannot say, since a dropped object that names no model could be anyone's.
+	*/
+	const _listChildObjects = async (objectType, modelUUID, signal) => {
+		const { objects, unreadable } = await _listObjects(objectType, SEMANTIC_CHILD_OBJECT_READ_SCHEMAS[objectType], signal);
+		return {
+			objects: objects.filter((object) => object.data.modelUUID === modelUUID),
+			unreadable: unreadable.filter((ref) => ref.modelUUID === null || ref.modelUUID === modelUUID)
+		};
+	};
+	const listObjects = async (objectType, modelUUID, signal) => (await _listChildObjects(objectType, modelUUID, signal)).objects;
+	/**
+	* 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 = {}) => 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 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 the collections are
+	* fetched whole and filtered client-side.
+	*
+	* **Throws `SemanticLayerUnreadableChildrenError` rather than degrading.** The list reads
+	* degrade — one malformed metric does not hide the other nine — but this answer is what
+	* `deleteModel` and every "what would this destroy?" confirmation is built on, and a short
+	* list there deletes the object it left out. An unreadable child is counted against the model
+	* whenever the raw envelope names it, and against every model when it cannot.
+	*/
+	const listModelChildren = async (modelUUID, signal) => {
+		const perType = await Promise.all(MODEL_CHILD_OBJECT_TYPES.map(async (objectType) => {
+			const { objects, unreadable } = await _listChildObjects(objectType, modelUUID, signal);
+			return {
+				children: objects.map((object) => ({
+					objectType,
+					objectUUID: object.uuid,
+					name: deriveObjectLabel(object.data)
+				})),
+				unreadable
+			};
+		}));
+		const unreadable = perType.flatMap((result) => result.unreadable);
+		if (unreadable.length > 0) throw new SemanticLayerUnreadableChildrenError({
+			modelUUID,
+			unreadable
+		});
+		return perType.flatMap((result) => result.children);
+	};
+	/**
+	* 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.
+	*
+	* The same holds for a child that could not be *read*: `listModelChildren` throws before the
+	* cascade starts, so an object the read boundary dropped keeps the model alive rather than
+	* being silently left behind pointing at a model that no longer exists.
+	*/
+	const deleteModel = async (modelUUID) => {
+		const children = await listModelChildren(modelUUID);
+		const outcomes = await 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
+export { RELATIONSHIP_JOIN_TYPES as _, createSemanticLayerSdk as a, metastoreErrorMessage as b, semanticDatasetSchema as c, semanticModelSchema as d, semanticRelationshipSchema as f, FIELD_ROLES as g, CONSTRAINT_TYPES as h, SemanticLayerUnreadableChildrenError as i, semanticGlossarySchema as l, CONSTRAINT_SEVERITIES as m, SEMANTIC_OBJECT_TYPE as n, SEMANTIC_CHILD_OBJECT_SCHEMAS as o, CONSTRAINT_SCOPES as p, SemanticLayerCascadeDeleteError as r, semanticConstraintSchema as s, MODEL_CHILD_OBJECT_TYPES as t, semanticMetricSchema as u, RULE_OPERATORS as v, SQL_DIALECTS as y };
+
+//# sourceMappingURL=semanticLayer-CSqmtHRo.js.map