@keboola/api-client 27.0.0 → 29.0.0

package/dist/sdk/semanticLayer/index.js

@@ -1,5 +1,347 @@
-export { CONSTRAINT_TYPES, MODEL_CHILD_OBJECT_TYPES, SEMANTIC_CHILD_OBJECT_SCHEMAS, SEMANTIC_OBJECT_TYPE, SQL_DIALECTS, SemanticLayerCascadeDeleteError, createSemanticLayerSdk, semanticConstraintSchema, semanticDatasetSchema, semanticGlossarySchema, semanticMetricSchema, semanticModelSchema, semanticRelationshipSchema } from '../../chunk-B45B4AYG.js';
-import '../../chunk-T526LPBK.js';
-import '../../chunk-ERZEQ5JR.js';
-//# sourceMappingURL=index.js.map
+import { t as concurrent } from "../../concurrent-CH9fbNr3.js";
+import { t as generateUUID } from "../../generateUUID-Dr8l-aoc.js";
+import { z } from "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
+});
+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 }) => {
+	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 = {}) => 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 `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 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 = 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
+export { CONSTRAINT_TYPES, MODEL_CHILD_OBJECT_TYPES, SEMANTIC_CHILD_OBJECT_SCHEMAS, SEMANTIC_OBJECT_TYPE, SQL_DIALECTS, SemanticLayerCascadeDeleteError, createSemanticLayerSdk, semanticConstraintSchema, semanticDatasetSchema, semanticGlossarySchema, semanticMetricSchema, semanticModelSchema, semanticRelationshipSchema };
+
 //# sourceMappingURL=index.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}
+{"version":3,"file":"index.js","names":[],"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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"}

package/dist/sdk/semanticLayer/types.cjs

@@ -1,4 +0,0 @@
-'use strict';
-
-//# sourceMappingURL=types.cjs.map
-//# sourceMappingURL=types.cjs.map

package/dist/sdk/semanticLayer/types.d.cts

@@ -1,152 +1,2 @@
-import { createMetastoreClient } from '../../metastore/index.cjs';
-import { C as CreateMetaObjectInput } from '../../types-BCBF_5cU.cjs';
-import '../../createOpenapiFetchClient-CduEua6F.cjs';
-import '../../types-UwuKN9Kx.cjs';
-import 'qs';
-import '../../types-f8dUjMX4.cjs';
-
-type MetastoreClient = ReturnType<typeof createMetastoreClient>;
-
-type SemanticFieldRole = 'key' | 'dimension' | 'measure' | 'timestamp';
-type SemanticAiMetadata = {
-    synonyms?: string[];
-    keywords?: string[];
-    antiKeywords?: string[];
-    hints?: string[];
-    warnings?: string[];
-};
-type SemanticModelData = {
-    name: string;
-    description?: string;
-    sql_dialect: string;
-};
-type SemanticFieldData = {
-    name: string;
-    description?: string;
-    type?: string;
-    role?: SemanticFieldRole;
-    values?: string[];
-    ai?: SemanticAiMetadata;
-};
-type SemanticDatasetData = {
-    modelUUID: string;
-    name: string;
-    tableId: string;
-    fqn: string;
-    description?: string;
-    grain?: string;
-    primaryKey?: string[];
-    fields?: SemanticFieldData[];
-    ai?: SemanticAiMetadata;
-};
-type SemanticMetricData = {
-    modelUUID: string;
-    name: string;
-    sql: string;
-    dataset?: string;
-    description?: string;
-};
-type SemanticRelationshipData = {
-    modelUUID: string;
-    name?: string;
-    from: string;
-    to: string;
-    on: string;
-    type?: 'left' | 'inner';
-};
-type SemanticGlossaryData = {
-    modelUUID: string;
-    term: string;
-    definition: string;
-    seeAlso?: string[];
-};
-type SemanticConstraintType = 'inequality' | 'equality' | 'range' | 'composition' | 'exclusion' | 'temporal' | 'conditional';
-type SemanticConstraintScope = 'global' | 'per_location' | 'per_date' | 'per_category';
-type SemanticRuleOperator = '<' | '<=' | '=' | '>=' | '>' | '!=' | 'between' | 'in' | 'sum_equals' | 'ratio_between';
-type SemanticRuleExpression = {
-    operator?: SemanticRuleOperator;
-    left?: string;
-    right?: string;
-    bounds?: {
-        min?: number;
-        max?: number;
-    };
-};
-type SemanticValidationQuery = {
-    default?: string;
-    snowflake?: string;
-    bigquery?: string;
-};
-type SemanticConstraintData = {
-    modelUUID: string;
-    name: string;
-    displayName?: string;
-    description?: string;
-    constraintType: SemanticConstraintType;
-    metrics: string[];
-    datasets?: string[];
-    rule: string;
-    ruleExpression?: SemanticRuleExpression;
-    validationQuery?: SemanticValidationQuery;
-    severity?: 'error' | 'warning' | 'info';
-    errorMessage?: string;
-    remediation?: string;
-    isActive?: boolean;
-    scope?: SemanticConstraintScope;
-    owner?: string;
-    tags?: string[];
-};
-type SemanticChildObjectDataMap = {
-    'semantic-dataset': SemanticDatasetData;
-    'semantic-metric': SemanticMetricData;
-    'semantic-relationship': SemanticRelationshipData;
-    'semantic-glossary': SemanticGlossaryData;
-    'semantic-constraint': SemanticConstraintData;
-};
-type SemanticChildObjectType = keyof SemanticChildObjectDataMap;
-type SemanticObjectType = SemanticChildObjectType | 'semantic-model';
-type SemanticObjectMeta = {
-    name?: string;
-    branch?: string;
-    projectId?: number;
-    organizationId?: string;
-    revision?: number;
-    schemaVersion?: string;
-    createdAt?: string;
-    lastUpdated?: string;
-    revisionCreatedAt?: string;
-};
-/**
- * Normalized metastore object as returned by this SDK. Matches the live metastore
- * envelope ({ type, id, attributes: <data payload>, meta: {...} }), which differs
- * from the legacy wrapper types in clients/metastore/repository/types.ts.
- */
-type SemanticObject<TData> = {
-    uuid: string;
-    data: TData;
-    meta: SemanticObjectMeta;
-};
-type CreateSemanticObjectMeta = Omit<CreateMetaObjectInput, 'data' | 'objectType'>;
-/**
- * Meta for a CONTENT update. `scope` is deliberately absent: a scope change is a separate PATCH
- * shape the metastore refuses to combine with name/data (see UpdateMetaObjectInput's union), and
- * it used to be accepted here — compiling fine and failing with a 400 on every live call.
- */
-type UpdateSemanticObjectMeta = {
-    name?: string;
-};
-/**
- * One child of a model as `listModelChildren` reports it: enough to address it (type + UUID)
- * and to label it for a user (`name` is the display label, see `deriveObjectLabel`).
- */
-type SemanticModelChildRef = {
-    objectType: SemanticChildObjectType;
-    objectUUID: string;
-    name: string | undefined;
-};
-/** A child `deleteModel` tried and failed to delete, with the error that delete rejected with. */
-type SemanticModelChildDeleteFailure = SemanticModelChildRef & {
-    error: unknown;
-};
-
-export type { CreateSemanticObjectMeta, MetastoreClient, SemanticAiMetadata, SemanticChildObjectDataMap, SemanticChildObjectType, SemanticConstraintData, SemanticConstraintScope, SemanticConstraintType, SemanticDatasetData, SemanticFieldData, SemanticFieldRole, SemanticGlossaryData, SemanticMetricData, SemanticModelChildDeleteFailure, SemanticModelChildRef, SemanticModelData, SemanticObject, SemanticObjectMeta, SemanticObjectType, SemanticRelationshipData, SemanticRuleExpression, SemanticRuleOperator, SemanticValidationQuery, UpdateSemanticObjectMeta };
+import { C as SemanticValidationQuery, S as SemanticRuleOperator, _ as SemanticObject, a as SemanticChildObjectType, b as SemanticRelationshipData, c as SemanticConstraintType, d as SemanticFieldRole, f as SemanticGlossaryData, g as SemanticModelData, h as SemanticModelChildRef, i as SemanticChildObjectDataMap, l as SemanticDatasetData, m as SemanticModelChildDeleteFailure, n as MetastoreClient, o as SemanticConstraintData, p as SemanticMetricData, r as SemanticAiMetadata, s as SemanticConstraintScope, t as CreateSemanticObjectMeta, u as SemanticFieldData, v as SemanticObjectMeta, w as UpdateSemanticObjectMeta, x as SemanticRuleExpression, y as SemanticObjectType } from "../../types-DBOEA7l0.cjs";
+export { CreateSemanticObjectMeta, MetastoreClient, SemanticAiMetadata, SemanticChildObjectDataMap, SemanticChildObjectType, SemanticConstraintData, SemanticConstraintScope, SemanticConstraintType, SemanticDatasetData, SemanticFieldData, SemanticFieldRole, SemanticGlossaryData, SemanticMetricData, SemanticModelChildDeleteFailure, SemanticModelChildRef, SemanticModelData, SemanticObject, SemanticObjectMeta, SemanticObjectType, SemanticRelationshipData, SemanticRuleExpression, SemanticRuleOperator, SemanticValidationQuery, UpdateSemanticObjectMeta };