sg-widgets-core 0.3.0 → 0.4.0

package/dist/mock.mjs

@@ -1,4 +1,269 @@
-import { A as NEGATING_OPERATORS, D as toFilterArray, I as isFilterable, L as isLinkType, N as TIME_UNITS, R as isNumericType, V as operatorsFor, a as eventLogFilters, d as displayNameOf, f as fieldSchemaOverride, r as SgApiError, s as normalizeEventLogEntry, t as EVENT_LOG_FIELDS, v as pluralPath } from "./client-izKszX7l.mjs";
+import { E as pluralPath, F as toFilterArray, J as isLinkType, Q as operatorsFor, T as undeclaredField, V as NEGATING_OPERATORS, W as TIME_UNITS, Y as isNumericType, b as fieldSchemaOverride, c as toSchemaProperties, d as SgApiError, h as normalizeEventLogEntry, i as SchemaApiError, l as EVENT_LOG_FIELDS, o as fieldFromRaw, p as eventLogFilters, q as isFilterable, y as displayNameOf, z as predictFieldName } from "./schema-write-D_WfMYW8.mjs";
+//#region src/schema-write-mock.ts
+/** The names an update's refusal lists as the ones it takes (116_field_settings_create_update). */
+const UPDATE_PROPERTIES = "[\"name\", \"visible\", \"description\", \"summary_default\", \"valid_values\", \"default_value\", \"custom_metadata\"]";
+/** The data types whose default an update may change (116_field_settings_create_update). */
+const DEFAULT_AFTER_CREATION = /* @__PURE__ */ new Set([
+	"status_list",
+	"list",
+	"checkbox"
+]);
+function refusal(status, error) {
+	const first = {
+		status,
+		code: error.code ?? (status === 404 ? 104 : 103),
+		title: error.title ?? null,
+		source: error.source ?? null,
+		detail: error.detail ?? null,
+		meta: null
+	};
+	return new SchemaApiError(status, { errors: [first] });
+}
+/** The 400 for a value sent empty, naming the property by its place in the list (116_field_settings_create_update). */
+function unfilled(index) {
+	return refusal(400, {
+		title: "Request Parameters invalid.",
+		source: { properties: { [String(index)]: { value: ["value must be filled"] } } }
+	});
+}
+function missing(entityType, field) {
+	return refusal(404, {
+		title: "Not Found",
+		detail: `Field '${entityType}.${field}' does not exist.`
+	});
+}
+function wrap(value, editable = false) {
+	return {
+		value,
+		editable
+	};
+}
+/** A normalised field back in the wrapped shape the API answers. */
+function rawFromField(field) {
+	const properties = {};
+	if (field.defaultValue !== void 0) properties["default_value"] = wrap(field.defaultValue);
+	if (field.validValues) properties["valid_values"] = wrap(field.validValues);
+	if (field.validTypes) properties["valid_types"] = wrap(field.validTypes);
+	if (field.displayValues) properties["display_values"] = wrap(field.displayValues);
+	if (field.hiddenValues) properties["hidden_values"] = wrap(field.hiddenValues);
+	return {
+		name: wrap(field.displayName, true),
+		...field.description ? { description: wrap(field.description, true) } : {},
+		custom_metadata: wrap("", true),
+		entity_type: wrap(field.entityType),
+		data_type: wrap(String(field.dataType)),
+		editable: wrap(field.editable),
+		mandatory: wrap(field.mandatory),
+		unique: wrap(field.unique),
+		visible: wrap(true, field.hideable ?? false),
+		properties
+	};
+}
+function apply(raw, changes) {
+	const next = structuredClone(raw);
+	for (const { property_name: key, value } of changes) if (key === "name") next.name = wrap(String(value), true);
+	else if (key === "description") next.description = wrap(String(value), next.description?.editable ?? true);
+	else if (key === "custom_metadata") next.custom_metadata = wrap(String(value), true);
+	else if (key === "unique") next.unique = wrap(Boolean(value));
+	else if (key === "visible") next.visible = wrap(Boolean(value), next.visible?.editable ?? true);
+	else if (key === "valid_types") next.properties[key] = wrap(value, next.data_type.value === "entity");
+	else next.properties[key] = wrap(value, next.properties[key]?.editable ?? false);
+	return next;
+}
+/**
+* Throw what the server answers to an update it refuses (040_field_revive,
+* 114_schema_admin_recheck, 116_field_settings_create_update). A default and
+* its valid values changed in one update are not measured, and pass.
+*/
+function refuseUpdate(current, changes) {
+	const type = current.data_type.value;
+	const sent = new Set(changes.map((change) => change.property_name));
+	const held = (key) => current.properties[key]?.value;
+	for (const [index, { property_name: name, value }] of changes.entries()) {
+		if (name === "data_type") throw refusal(400, { title: "API schema_field_update() invalid property 'data_type'" });
+		if (name === "hidden_values") throw refusal(400, { title: `API schema_field_update() invalid property 'hidden_values': Valid property names: ["name", "visible", "description", "summary_default", "default_value", "valid_values", "custom_metadata"]` });
+		if (name === "unique") {
+			if (current.unique.value) throw refusal(500, {
+				code: 105,
+				title: "API schema_field_update() does not support updating 'unique'."
+			});
+			throw refusal(400, { title: `API schema_field_update() invalid property 'unique': Valid property names: ${UPDATE_PROPERTIES}` });
+		}
+		if (name === "valid_types" && type === "multi_entity") throw refusal(400, { title: "API schema_field_update() can't update 'valid_types' on this field" });
+		if (name === "default_value") {
+			if (value === null || value === "") throw unfilled(index);
+			if (!DEFAULT_AFTER_CREATION.has(type)) throw refusal(400, { title: "API schema_field_update() default value is read-only for all data types except status_list, list, checkbox" });
+			const values = held("valid_values");
+			if ((type === "list" || type === "status_list") && !sent.has("valid_values") && !(Array.isArray(values) && values.includes(value))) throw refusal(400, { title: `API schema_field_update() 'default_value' not in valid_values : ${JSON.stringify(values ?? [])}` });
+		}
+		if (name === "valid_values" && (type === "list" || type === "status_list")) {
+			if (Array.isArray(value) && value.length === 0) throw unfilled(index);
+			const fallback = held("default_value");
+			if (type === "status_list" && !sent.has("default_value") && typeof fallback === "string" && Array.isArray(value) && !value.includes(fallback)) throw refusal(400, { title: `API schema_field_update() 'valid_values' ${JSON.stringify(value)} must include the 'default_value' '${fallback}'` });
+		}
+	}
+}
+var MockSchemaClient = class {
+	base;
+	/** Fields this client created or wrote, by `Type.field`. */
+	live = /* @__PURE__ */ new Map();
+	/** Retired fields. The name stays taken and no read lists it (040_field_revive). */
+	retired = /* @__PURE__ */ new Map();
+	/** Writes made at a project's scope, by `Type.field@project`. */
+	scoped = /* @__PURE__ */ new Map();
+	pendingFailure;
+	constructor(options = {}) {
+		this.base = options.client ?? null;
+		this.pendingFailure = options.failNext ?? null;
+	}
+	/** Make the next call reject with a `SchemaApiError`. Pass `null` to disarm. */
+	failNext(failure = {}) {
+		this.pendingFailure = failure;
+	}
+	gate() {
+		const failure = this.pendingFailure;
+		this.pendingFailure = null;
+		if (failure) throw refusal(failure.status ?? 500, { title: failure.message ?? `Flow PT API error ${failure.status ?? 500}` });
+	}
+	/** The base client's fields of a type; an unknown type is its 404. */
+	async baseFields(entityType, projectId) {
+		if (!this.base) return {};
+		try {
+			return await this.base.fields(entityType, projectId);
+		} catch (error) {
+			if (error instanceof SgApiError && !(error instanceof SchemaApiError)) throw refusal(error.status, error.status === 404 ? {
+				title: "Not Found",
+				detail: error.message
+			} : { title: error.message });
+			throw error;
+		}
+	}
+	/** Every live record of a type at a scope, this client's writes over the base client's fields. */
+	async records(entityType, projectId) {
+		const out = {};
+		for (const [name, field] of Object.entries(await this.baseFields(entityType, projectId))) {
+			const key = `${entityType}.${name}`;
+			if (this.retired.has(key)) continue;
+			const written = this.live.get(key);
+			if (!written) {
+				out[name] = rawFromField(field);
+				continue;
+			}
+			const record = structuredClone(written);
+			if (field.hiddenValues) record.properties["hidden_values"] = wrap(field.hiddenValues);
+			else delete record.properties["hidden_values"];
+			out[name] = record;
+		}
+		for (const [key, record] of this.live) {
+			const name = key.slice(entityType.length + 1);
+			if (key.startsWith(`${entityType}.`) && !out[name]) out[name] = structuredClone(record);
+		}
+		if (projectId !== void 0) for (const [name, record] of Object.entries(out)) {
+			const changes = this.scoped.get(`${entityType}.${name}@${projectId}`);
+			if (changes) out[name] = apply(record, changes);
+		}
+		return out;
+	}
+	async readField(entityType, field, projectId) {
+		this.gate();
+		const raw = (await this.records(entityType, projectId))[field];
+		if (raw) return {
+			status: "found",
+			field: fieldFromRaw(entityType, field, raw),
+			raw
+		};
+		if (undeclaredField(entityType, field)) return { status: "undeclared" };
+		return {
+			status: "missing",
+			message: missing(entityType, field).message
+		};
+	}
+	async readRawFields(entityType, projectId) {
+		this.gate();
+		return this.records(entityType, projectId);
+	}
+	async createField(entityType, input) {
+		this.gate();
+		const existing = await this.records(entityType);
+		const given = toSchemaProperties(input.properties);
+		const valueOf = (key) => given.find((p) => p.property_name === key)?.value;
+		const type = input.dataType;
+		if (type === "color" || type === "image") throw refusal(400, {
+			title: "Request Parameters invalid.",
+			source: { data_type: ["data_type is not valid"] }
+		});
+		if (type === "calculated") throw refusal(500, { title: "NoMethodError" });
+		if (type === "checkbox" && typeof valueOf("default_value") !== "boolean") throw refusal(500, { title: "Only true or false allowed in checkbox" });
+		if (type === "status_list" && valueOf("valid_values") === void 0) throw refusal(400, { title: `API schema_field_create() missing required 'properties' ["valid_values"]` });
+		if (type === "entity" || type === "multi_entity") {
+			const validTypes = valueOf("valid_types");
+			if (validTypes === void 0) throw refusal(400, { title: "missing required 'properties'" });
+			const count = Array.isArray(validTypes) ? validTypes.length : 0;
+			if (type === "multi_entity" ? count !== 1 : count < 1) throw refusal(400, { title: "'valid_types' value expected Array with one element" });
+		}
+		const wanted = predictFieldName(input.displayName, type) ?? "sg_";
+		let name = wanted;
+		for (let n = 1; existing[name]; n += 1) name = `${wanted}_${n}`;
+		if (this.retired.has(`${entityType}.${name}`)) throw refusal(400, { title: `API schema_field_create() failed, there is a retired field with the same field_name: ${name}. Delete the retired field forever from the Trash Page in Shotgun and try again.` });
+		const record = apply({
+			name: wrap(input.displayName, true),
+			custom_metadata: wrap("", true),
+			entity_type: wrap(entityType),
+			data_type: wrap(type),
+			editable: wrap(true),
+			mandatory: wrap(false),
+			unique: wrap(false),
+			visible: wrap(true, true),
+			properties: { default_value: wrap(null) }
+		}, given);
+		this.live.set(`${entityType}.${name}`, record);
+		return {
+			name,
+			self: `/api/v1/schema/${entityType}/fields/${name}`,
+			raw: structuredClone(record)
+		};
+	}
+	async updateField(entityType, field, properties, projectId) {
+		this.gate();
+		const key = `${entityType}.${field}`;
+		const current = (await this.records(entityType))[field];
+		if (!current) throw missing(entityType, field);
+		const changes = toSchemaProperties(properties);
+		if (changes.length === 0) throw refusal(400, { title: "API schema_field_update() can't create/update with no 'properties'" });
+		refuseUpdate(current, changes);
+		if (projectId === void 0) this.live.set(key, apply(current, changes));
+		else {
+			const scope = `${key}@${projectId}`;
+			this.scoped.set(scope, [...this.scoped.get(scope) ?? [], ...changes]);
+		}
+		return (await this.records(entityType, projectId))[field] ?? null;
+	}
+	async retireField(entityType, field) {
+		this.gate();
+		const current = (await this.records(entityType))[field];
+		if (!current) throw missing(entityType, field);
+		const key = `${entityType}.${field}`;
+		this.live.delete(key);
+		this.retired.set(key, current);
+	}
+	async reviveField(entityType, field) {
+		this.gate();
+		const key = `${entityType}.${field}`;
+		const record = this.retired.get(key);
+		if (!record) {
+			const error = missing(entityType, field);
+			return {
+				revived: false,
+				status: error.status,
+				message: error.message
+			};
+		}
+		this.retired.delete(key);
+		this.live.set(key, record);
+		return { revived: true };
+	}
+};
+//#endregion
 //#region src/mock.ts
 /**
 * Status vocabularies. `valid_values` is the site's whole vocabulary and is
@@ -3828,4 +4093,4 @@ function toStatusIcon(values) {
 	}
 }
 //#endregion
-export { MOCK_NOW, MockClient };
+export { MOCK_NOW, MockClient, MockSchemaClient };