@cmflow/atlas 3.7.1 → 3.8.1

package/dist/{dist-D8VumL0r.mjs → dist-DIU2ATkt.mjs}

@@ -55,6 +55,25 @@ async function loadOpenApiDocument(url, timeoutMs) {
 	}
 }
 
+//#endregion
+//#region src/utils/pickPropertyMetadata.ts
+/**
+* Picks the shape-describing fields (`data_type`/`original_type`/`format`/`pattern`/`is_nullable`/
+* `enum_values`) off any `PropertyMetadata`-shaped source. Spread this at every call site that
+* copies a resolved backend/API property into a catalogue record, instead of repeating the same
+* six fields.
+*/
+function pickPropertyMetadata(source) {
+	return {
+		data_type: source?.data_type,
+		original_type: source?.original_type,
+		format: source?.format,
+		pattern: source?.pattern,
+		is_nullable: source?.is_nullable,
+		enum_values: source?.enum_values
+	};
+}
+
 //#endregion
 //#region src/services/openapi/utils/resolveOpenApiReference.ts
 function resolveOpenApiReference(value, document) {
@@ -67,8 +86,210 @@ function resolveOpenApiReference(value, document) {
 	return current === void 0 ? value : current;
 }
 
+//#endregion
+//#region src/utils/transformTypeFrom.ts
+/** Known OpenAPI `type`+`format` pairs that promote to a distinct base type. */
+const FORMAT_PROMOTIONS = {
+	"integer:int32": "integer",
+	"integer:int64": "long",
+	"number:float": "float",
+	"number:double": "double",
+	"string:date": "date",
+	"string:date-time": "date-time"
+};
+/** Internal base key used as the default when nothing else matches — spelling matches `PropertyDataType["unknow"]`. */
+const DEFAULT_BASE = "unknow";
+/**
+* Closed, exhaustive set of `data_type` predefined_values (`type: "data_type"` in Directus),
+* keyed by the base half of `PropertyDataType` (i.e. without its `[]` suffix). This is the exact
+* list — ids/labels are NOT derived, they must match the existing rows verbatim (note the
+* historical quirks: the `unknow` base's row id is `UNKNOWN`, correctly spelled, while its label
+* keeps the typo `Unknow`; `UUID_ARRAY` has no `[]` suffix in its label).
+*/
+const BASE_TYPES = {
+	unknow: {
+		id: "UNKNOWN",
+		label: "Unknow"
+	},
+	string: {
+		id: "STRING",
+		label: "String",
+		arrayId: "STRING_ARRAY",
+		arrayLabel: "String[]"
+	},
+	uuid: {
+		id: "UUID",
+		label: "Uuid",
+		arrayId: "UUID_ARRAY",
+		arrayLabel: "Uuid"
+	},
+	number: {
+		id: "NUMBER",
+		label: "Number",
+		arrayId: "NUMBER_ARRAY",
+		arrayLabel: "Number[]"
+	},
+	integer: {
+		id: "INTEGER",
+		label: "Integer",
+		arrayId: "INTEGER_ARRAY",
+		arrayLabel: "Integer[]"
+	},
+	float: {
+		id: "FLOAT",
+		label: "Float",
+		arrayId: "FLOAT_ARRAY",
+		arrayLabel: "Float[]"
+	},
+	double: {
+		id: "DOUBLE",
+		label: "Double",
+		arrayId: "DOUBLE_ARRAY",
+		arrayLabel: "Double[]"
+	},
+	long: {
+		id: "LONG",
+		label: "Long",
+		arrayId: "LONG_ARRAY",
+		arrayLabel: "Long[]"
+	},
+	decimal: {
+		id: "DECIMAL",
+		label: "Decimal",
+		arrayId: "DECIMAL_ARRAY",
+		arrayLabel: "Decimal[]"
+	},
+	boolean: {
+		id: "BOOLEAN",
+		label: "Boolean",
+		arrayId: "BOOLEAN_ARRAY",
+		arrayLabel: "Boolean[]"
+	},
+	date: {
+		id: "DATE",
+		label: "Date",
+		arrayId: "DATE_ARRAY",
+		arrayLabel: "Date[]"
+	},
+	"date-time": {
+		id: "DATETIME",
+		label: "DateTime",
+		arrayId: "DATETIME_ARRAY",
+		arrayLabel: "DateTime[]"
+	},
+	time: {
+		id: "TIME",
+		label: "Time",
+		arrayId: "TIME_ARRAY",
+		arrayLabel: "Time[]"
+	},
+	timestamp: {
+		id: "TIMESTAMP",
+		label: "Timestamp",
+		arrayId: "TIMESTAMP_ARRAY",
+		arrayLabel: "Timestamp[]"
+	},
+	object: {
+		id: "OBJECT",
+		label: "Object",
+		arrayId: "OBJECT_ARRAY",
+		arrayLabel: "Object[]"
+	}
+};
+/**
+* Raw backend/OpenAPI keywords mapped to a base above. Anything not listed degrades to
+* `unknow` rather than being dropped; the exact original keyword is preserved verbatim in
+* `original_type` instead (a free-form field — see BackendProperty/RouteProperty's dedicated
+* columns). Add new synonyms here as new sources are integrated.
+*/
+const TYPE_ALIASES = {
+	string: "string",
+	number: "number",
+	integer: "integer",
+	int: "integer",
+	float: "float",
+	double: "double",
+	long: "long",
+	decimal: "decimal",
+	boolean: "boolean",
+	bool: "boolean",
+	date: "date",
+	"date-time": "date-time",
+	datetime: "date-time",
+	time: "time",
+	timestamp: "timestamp",
+	object: "object",
+	uuid: "uuid",
+	json: "object",
+	text: "string",
+	localized_text: "string",
+	unlocalized_text: "string",
+	multiline_text: "string",
+	multi_select: "string",
+	simple_select: "string",
+	switch: "boolean",
+	alias: "string"
+};
+/** Raw keywords that are inherently multi-valued (no `[]` suffix needed to detect it). */
+const ARRAY_ALIASES = /* @__PURE__ */ new Set(["multi_select"]);
+function resolveBaseKey(rawType) {
+	return TYPE_ALIASES[rawType.trim().toLowerCase()] || DEFAULT_BASE;
+}
+/**
+* Normalizes any raw backend/OpenAPI type (+ optional format, for `int64`/`date-time`-style
+* promotions) to the closed `PropertyDataType` Atlas carries end to end as `data_type`. Handles
+* explicit `Type[]`/`Array<Type>` syntax and inherently plural keywords like `multi_select`.
+* Always resolves to something — an unrecognized type degrades to `unknow` rather than being
+* dropped; callers should keep the original keyword in `original_type`.
+*/
+function toPropertyDataType(type, format) {
+	const sourceType = typeof type === "string" ? type : void 0;
+	const sourceFormat = typeof format === "string" ? format : void 0;
+	let rawType = sourceType;
+	if (sourceType && sourceFormat) rawType = FORMAT_PROMOTIONS[`${sourceType.toLowerCase()}:${sourceFormat.toLowerCase()}`] ?? sourceType;
+	if (!rawType) return DEFAULT_BASE;
+	const arrayMatch = rawType.trim().match(/^(.+)\[\]$/) || rawType.trim().match(/^array<(.+)>$/i);
+	if (arrayMatch) return `${resolveBaseKey(arrayMatch[1])}[]`;
+	const base = resolveBaseKey(rawType);
+	return ARRAY_ALIASES.has(rawType.trim().toLowerCase()) ? `${base}[]` : base;
+}
+/**
+* Maps an already-normalized `PropertyDataType` to its Directus `predefined_values` `{id, label}`
+* (`type: "data_type"`). The only caller should be the push step (`resolveDataTypeReference`) —
+* everywhere else in the pipeline carries the closed `PropertyDataType` itself, produced once by
+* `toPropertyDataType` at extraction/declaration time.
+*/
+function transformTypeFrom(dataType) {
+	const key = dataType || DEFAULT_BASE;
+	const isArray = key.endsWith("[]");
+	const baseKey = isArray ? key.slice(0, -2) : key;
+	const entry = BASE_TYPES[baseKey] ?? BASE_TYPES[DEFAULT_BASE];
+	return isArray ? {
+		id: entry.arrayId ?? entry.id,
+		label: entry.arrayLabel ?? entry.label
+	} : {
+		id: entry.id,
+		label: entry.label
+	};
+}
+
 //#endregion
 //#region src/services/openapi/utils/extractOpenApiLeafProperties.ts
+/**
+* Builds a leaf property's shape from a schema: `original_type`/`format`/`pattern`/`is_nullable`/
+* `enum_values` are copied as-is (free-form, kept verbatim end to end), while `data_type` is
+* normalized up front via `toPropertyDataType` since it's a closed `PropertyDataType` value.
+*/
+function toRawShape(schema) {
+	return {
+		data_type: toPropertyDataType(schema?.type, schema?.format),
+		original_type: schema?.type,
+		format: schema?.format,
+		pattern: schema?.pattern,
+		is_nullable: schema?.nullable,
+		enum_values: Array.isArray(schema?.enum) ? schema.enum.map(String) : void 0
+	};
+}
 function extractOpenApiLeafProperties(schema, document, currentPath = "") {
 	const resolvedSchema = resolveOpenApiReference(schema, document);
 	if (!resolvedSchema || typeof resolvedSchema !== "object") return [];
@@ -82,7 +303,7 @@ function extractOpenApiLeafProperties(schema, document, currentPath = "") {
 		path: currentPath,
 		description: resolvedSchema.description,
 		deprecated: resolvedSchema.deprecated,
-		type: resolvedSchema.type
+		...toRawShape(resolvedSchema)
 	}] : [];
 	return Object.entries(properties).flatMap(([propertyName, propertySchema]) => {
 		return extractOpenApiLeafProperties(propertySchema, document, currentPath ? `${currentPath}.${propertyName}` : propertyName);
@@ -127,7 +348,7 @@ function extractOpenApiInputProperties(operation, swagger) {
 			path: parameter.name,
 			description: parameter.description,
 			deprecated: parameter.deprecated,
-			type: parameter.schema?.type
+			...toRawShape(parameter.schema)
 		}];
 		for (const property of resolvedProperties) map.set(`${location}:${property.path}`, {
 			path: property.path,
@@ -135,7 +356,7 @@ function extractOpenApiInputProperties(operation, swagger) {
 			deprecated: property.deprecated ?? parameter.deprecated ?? false,
 			direction: "input",
 			location,
-			type: property.type
+			...pickPropertyMetadata(property)
 		});
 	}
 	const requestBody = resolveOpenApiReference(operation.requestBody, swagger);
@@ -147,7 +368,7 @@ function extractOpenApiInputProperties(operation, swagger) {
 			deprecated: property.deprecated ?? false,
 			direction: "input",
 			location: "body",
-			type: property.type
+			...pickPropertyMetadata(property)
 		});
 	}
 	return [...map.values()];
@@ -165,7 +386,7 @@ function extractOpenApiOutputProperties(operation, swagger) {
 			deprecated: property.deprecated ?? false,
 			direction: "output",
 			location: "body",
-			type: property.type
+			...pickPropertyMetadata(property)
 		});
 		for (const [headerName, rawHeader] of Object.entries(response?.headers || {})) {
 			const header = resolveOpenApiReference(rawHeader, swagger);
@@ -174,7 +395,7 @@ function extractOpenApiOutputProperties(operation, swagger) {
 				path: headerName,
 				description: header?.description,
 				deprecated: void 0,
-				type: header?.schema?.type
+				...toRawShape(header?.schema)
 			}];
 			for (const property of resolvedProperties) map.set(`header:${property.path}`, {
 				path: property.path,
@@ -182,7 +403,7 @@ function extractOpenApiOutputProperties(operation, swagger) {
 				deprecated: property.deprecated ?? false,
 				direction: "output",
 				location: "header",
-				type: property.type
+				...pickPropertyMetadata(property)
 			});
 		}
 	}
@@ -202,7 +423,7 @@ function extractOpenApiBackendProperties(swagger) {
 				description: property.description,
 				direction: property.direction,
 				location: property.location,
-				type: property.type
+				...pickPropertyMetadata(property)
 			});
 		}
 	}
@@ -6946,5 +7167,5 @@ var require_dist = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-export { loadOpenApiDocument as a, extractOpenApiOutputProperties as i, extractOpenApiBackendProperties as n, httpClient as o, extractOpenApiInputProperties as r, require_dist as t };
-//# sourceMappingURL=dist-D8VumL0r.mjs.map
+export { toPropertyDataType as a, loadOpenApiDocument as c, extractOpenApiOutputProperties as i, httpClient as l, extractOpenApiBackendProperties as n, transformTypeFrom as o, extractOpenApiInputProperties as r, pickPropertyMetadata as s, require_dist as t };
+//# sourceMappingURL=dist-DIU2ATkt.mjs.map