@omnixdp/typegen 0.1.0

package/README.md

@@ -0,0 +1,48 @@
+# @omnixdp/typegen
+
+Generate TypeScript types for Omni xDP SDK responses from live CMS, Business Objects, and Ratings and Reviews schemas.
+
+## Install
+
+```bash
+npm install -D @omnixdp/typegen
+```
+
+## Generate
+
+```bash
+npx omnixdp-typegen \
+  --api-url https://api.example.com \
+  --management-token "$OMNIXDP_MANAGEMENT_TOKEN" \
+  --business-objects-token "$OMNIXDP_BO_TOKEN" \
+  --ratings-and-reviews-token "$OMNIXDP_RR_TOKEN" \
+  --cms-space marketing \
+  --bo-space products \
+  --rr-space storefront-reviews \
+  --out src/omnixdp.generated.ts
+```
+
+Space arguments can be a space id, slug, or exact name. Regenerate the output after changing content types, taxonomy types, data types, or global fields in the admin.
+
+## Check in CI
+
+```bash
+npx omnixdp-typegen --config omnixdp.typegen.config.js --check
+```
+
+`--check` fails when the generated output is stale.
+
+## Config File
+
+```js
+module.exports = {
+  apiUrl: process.env.OMNIXDP_API_URL,
+  managementToken: process.env.OMNIXDP_MANAGEMENT_TOKEN,
+  businessObjectsToken: process.env.OMNIXDP_BO_TOKEN,
+  ratingsAndReviewsToken: process.env.OMNIXDP_RR_TOKEN,
+  cmsSpace: "marketing",
+  boSpace: "products",
+  rrSpace: "storefront-reviews",
+  out: "src/omnixdp.generated.ts"
+};
+```

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const node_url_1 = require("node:url");
+const fetch_schema_1 = require("./fetch-schema");
+const generate_1 = require("./generate");
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    if (args.help) {
+        printHelp();
+        return;
+    }
+    const fileConfig = args.config ? await loadConfig(args.config) : await loadDefaultConfig();
+    const config = compactConfig({ ...fileConfig, ...args });
+    const out = config.out ?? "src/omnixdp.generated.ts";
+    if (!config.apiUrl) {
+        throw new Error("--api-url or apiUrl in config is required");
+    }
+    const schema = await (0, fetch_schema_1.fetchTypegenSchema)(config);
+    const output = (0, generate_1.generateTypes)({ schema });
+    const outPath = (0, node_path_1.resolve)(process.cwd(), out);
+    if (args.check) {
+        const current = await (0, promises_1.readFile)(outPath, "utf8").catch(() => "");
+        if (current !== output) {
+            throw new Error(`${out} is out of date. Run omnixdp-typegen to regenerate it.`);
+        }
+        console.log(`${out} is up to date.`);
+        return;
+    }
+    await (0, promises_1.mkdir)((0, node_path_1.dirname)(outPath), { recursive: true });
+    await (0, promises_1.writeFile)(outPath, output, "utf8");
+    console.log(`Generated ${out}`);
+}
+function parseArgs(argv) {
+    const out = {};
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--help" || arg === "-h") {
+            out.help = true;
+            continue;
+        }
+        if (arg === "--check") {
+            out.check = true;
+            continue;
+        }
+        if (!arg.startsWith("--")) {
+            throw new Error(`Unexpected argument: ${arg}`);
+        }
+        const key = arg.slice(2);
+        const value = argv[i + 1];
+        if (!value || value.startsWith("--")) {
+            throw new Error(`Missing value for ${arg}`);
+        }
+        i += 1;
+        assignArg(out, key, value);
+    }
+    return out;
+}
+function assignArg(out, key, value) {
+    switch (key) {
+        case "api-url":
+            out.apiUrl = value;
+            break;
+        case "management-token":
+            out.managementToken = value;
+            break;
+        case "business-objects-token":
+            out.businessObjectsToken = value;
+            break;
+        case "ratings-and-reviews-token":
+            out.ratingsAndReviewsToken = value;
+            break;
+        case "cms-space":
+            out.cmsSpace = value;
+            break;
+        case "bo-space":
+            out.boSpace = value;
+            break;
+        case "rr-space":
+            out.rrSpace = value;
+            break;
+        case "out":
+            out.out = value;
+            break;
+        case "config":
+            out.config = value;
+            break;
+        default:
+            throw new Error(`Unknown option: --${key}`);
+    }
+}
+async function loadDefaultConfig() {
+    for (const file of ["omnixdp.typegen.config.ts", "omnixdp.typegen.config.js", "omnixdp.typegen.config.cjs", "omnixdp.typegen.config.json"]) {
+        const config = await loadConfig(file).catch((error) => {
+            if (error.code === "ENOENT")
+                return null;
+            throw error;
+        });
+        if (config)
+            return config;
+    }
+    return {};
+}
+async function loadConfig(file) {
+    const path = (0, node_path_1.resolve)(process.cwd(), file);
+    if (path.endsWith(".json")) {
+        return JSON.parse(await (0, promises_1.readFile)(path, "utf8"));
+    }
+    const imported = await Promise.resolve(`${(0, node_url_1.pathToFileURL)(path).href}`).then(s => __importStar(require(s)));
+    return (imported.default ?? imported.config ?? imported);
+}
+function compactConfig(config) {
+    return Object.fromEntries(Object.entries(config).filter(([, value]) => value !== undefined && value !== ""));
+}
+function printHelp() {
+    console.log(`Usage: omnixdp-typegen --api-url <url> [options]
+
+Options:
+  --config <path>                    Load omnixdp typegen config
+  --management-token <token>          CMS Management API bearer token
+  --business-objects-token <token>    Business Objects API bearer token
+  --ratings-and-reviews-token <token> Ratings and Reviews API bearer token
+  --cms-space <id|slug|name>          CMS space to generate
+  --bo-space <id|slug|name>           Business Objects space to generate
+  --rr-space <id|slug|name>           Ratings and Reviews space to generate
+  --out <path>                        Output file, default src/omnixdp.generated.ts
+  --check                             Fail if the output file is stale
+`);
+}
+main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+});

package/dist/fetch-schema.d.ts

@@ -0,0 +1,3 @@
+import type { TypegenConfig, TypegenSchema } from "./schema";
+export declare function normalizeApiUrl(apiUrl: string): string;
+export declare function fetchTypegenSchema(config: TypegenConfig): Promise<TypegenSchema>;

package/dist/fetch-schema.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeApiUrl = normalizeApiUrl;
+exports.fetchTypegenSchema = fetchTypegenSchema;
+function normalizeApiUrl(apiUrl) {
+    const trimmed = apiUrl.trim().replace(/\/+$/, "");
+    if (!trimmed)
+        throw new Error("apiUrl is required");
+    return trimmed.endsWith("/v1") ? trimmed : `${trimmed}/v1`;
+}
+async function fetchTypegenSchema(config) {
+    const apiBase = normalizeApiUrl(config.apiUrl);
+    const [cms, businessObjects, ratingsAndReviews] = await Promise.all([
+        config.managementToken && config.cmsSpace
+            ? fetchCmsSchema(apiBase, config.managementToken, config.cmsSpace)
+            : Promise.resolve({ contentTypes: [], taxonomyTypes: [] }),
+        config.businessObjectsToken && config.boSpace
+            ? fetchBoSchema(apiBase, "business-objects", config.businessObjectsToken, config.boSpace)
+            : Promise.resolve({ dataTypes: [] }),
+        config.ratingsAndReviewsToken && config.rrSpace
+            ? fetchBoSchema(apiBase, "ratings-and-reviews", config.ratingsAndReviewsToken, config.rrSpace)
+            : Promise.resolve({ dataTypes: [] })
+    ]);
+    const canonical = JSON.stringify({ cms, businessObjects, ratingsAndReviews });
+    return {
+        generatedAt: new Date().toISOString(),
+        sourceHash: await hashText(canonical),
+        cms,
+        businessObjects,
+        ratingsAndReviews
+    };
+}
+async function fetchCmsSchema(apiBase, token, spaceRef) {
+    const space = await resolveSpace(apiBase, "management", token, spaceRef);
+    const [contentTypes, taxonomyTypes] = await Promise.all([
+        fetchModels(apiBase, "management", token, "content-types", space.id),
+        fetchModels(apiBase, "management", token, "taxonomy-types", space.id)
+    ]);
+    return { space, contentTypes, taxonomyTypes };
+}
+async function fetchBoSchema(apiBase, app, token, spaceRef) {
+    const space = await resolveSpace(apiBase, app, token, spaceRef);
+    const dataTypes = await fetchModels(apiBase, app, token, "data-types", space.id);
+    return { space, dataTypes };
+}
+async function resolveSpace(apiBase, app, token, spaceRef) {
+    const spaces = await apiGet(apiBase, app, token, "spaces", { limit: "500" });
+    const wanted = spaceRef.trim();
+    const match = spaces.find((space) => space.id === wanted || space.slug === wanted || space.name === wanted);
+    if (!match?.id || !match.name || !match.slug) {
+        throw new Error(`Space "${spaceRef}" was not found in ${app}`);
+    }
+    return { id: match.id, name: match.name, slug: match.slug };
+}
+async function fetchModels(apiBase, app, token, resource, spaceId) {
+    const rows = await apiGet(apiBase, app, token, resource, { spaceId, limit: "500", includeArchived: "1" });
+    return rows
+        .filter((row) => Boolean(row.id && row.name && row.apiIdentifier))
+        .map((row) => ({
+        id: row.id,
+        name: row.name,
+        apiIdentifier: row.apiIdentifier,
+        fields: normalizeFields(row.fields ?? [])
+    }));
+}
+async function apiGet(apiBase, app, token, resource, query) {
+    const url = new URL(`${apiBase}/${app}/${resource}`);
+    for (const [key, value] of Object.entries(query)) {
+        url.searchParams.set(key, value);
+    }
+    const response = await fetch(url, {
+        headers: {
+            accept: "application/json",
+            authorization: `Bearer ${token}`
+        }
+    });
+    const body = (await response.json().catch(() => null));
+    if (!response.ok || !body || body.success !== true) {
+        const message = body && "error" in body ? body.error?.message : undefined;
+        throw new Error(`Failed to fetch ${app}/${resource}: ${message ?? response.statusText}`);
+    }
+    return body.data;
+}
+function normalizeFields(fields) {
+    return fields
+        .filter((field) => field.name && field.apiIdentifier && field.type)
+        .map((field) => {
+        const validations = isRecord(field.validations) ? field.validations : null;
+        return {
+            id: field.id,
+            name: field.name,
+            apiIdentifier: field.apiIdentifier,
+            type: field.type,
+            required: field.required === true,
+            multiple: field.multiple === true || validations?.__multiple === true,
+            localizable: field.localizable === true || validations?.__localizable === true,
+            deliveryApi: field.deliveryApi === true || validations?.__deliveryApi === true,
+            validations,
+            fields: nestedFields(field, validations),
+            globalFieldApiIdentifier: field.globalField?.apiIdentifier,
+            referenceTarget: readReferenceTarget(validations)
+        };
+    });
+}
+function nestedFields(field, validations) {
+    if (Array.isArray(field.globalField?.fields))
+        return normalizeFields(field.globalField.fields);
+    const groupSchema = isRecord(validations?.groupSchema) ? validations.groupSchema : undefined;
+    const blockSchema = isRecord(validations?.blockSchema) ? validations.blockSchema : undefined;
+    const schema = groupSchema ?? blockSchema;
+    return Array.isArray(schema?.fields) ? normalizeFields(schema.fields) : undefined;
+}
+function readReferenceTarget(validations) {
+    const raw = validations?.referenceTarget;
+    if (!isRecord(raw))
+        return undefined;
+    return {
+        spaceId: typeof raw.spaceId === "string" ? raw.spaceId : undefined,
+        contentTypeId: typeof raw.contentTypeId === "string" ? raw.contentTypeId : undefined,
+        dataTypeId: typeof raw.dataTypeId === "string" ? raw.dataTypeId : undefined
+    };
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+async function hashText(text) {
+    const bytes = new TextEncoder().encode(text);
+    const digest = await crypto.subtle.digest("SHA-256", bytes);
+    return Array.from(new Uint8Array(digest))
+        .map((byte) => byte.toString(16).padStart(2, "0"))
+        .join("");
+}

package/dist/generate.d.ts

@@ -0,0 +1,5 @@
+import type { TypegenSchema } from "./schema";
+export type GenerateTypesOptions = {
+    schema: TypegenSchema;
+};
+export declare function generateTypes({ schema }: GenerateTypesOptions): string;

package/dist/generate.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTypes = generateTypes;
+function generateTypes({ schema }) {
+    const sections = [
+        renderHeader(schema),
+        renderSharedTypes(),
+        renderModelTypes("Cms", "ContentTypes", schema.cms.contentTypes),
+        renderModelTypes("Cms", "TaxonomyTypes", schema.cms.taxonomyTypes),
+        renderModelTypes("BusinessObject", "DataTypes", schema.businessObjects.dataTypes),
+        renderModelTypes("RatingsReview", "DataTypes", schema.ratingsAndReviews.dataTypes),
+        renderConvenienceAliases(schema)
+    ].filter(Boolean);
+    return `${sections.join("\n\n")}\n`;
+}
+function renderHeader(schema) {
+    const lines = [
+        "/* eslint-disable */",
+        "// This file is generated by @omnixdp/typegen. Do not edit it manually.",
+        `// Generated at: ${schema.generatedAt}`,
+        `// Schema hash: ${schema.sourceHash}`
+    ];
+    if (usesDeliveryTypes(schema)) {
+        lines.push("", "import type { DeliveryAsset, DeliveryEntry, DeliveryTaxonomyResponse } from \"@omnixdp/delivery\";");
+    }
+    return lines.join("\n");
+}
+function renderSharedTypes() {
+    return [
+        "export type OmnixdpJsonPrimitive = string | number | boolean | null;",
+        "export type OmnixdpJsonValue = OmnixdpJsonPrimitive | OmnixdpJsonValue[] | { [key: string]: OmnixdpJsonValue };",
+        "export type OmnixdpUploadValue = {",
+        "  id?: string;",
+        "  fileName?: string;",
+        "  url?: string;",
+        "  mimeType?: string | null;",
+        "  sizeBytes?: number | null;",
+        "  [key: string]: OmnixdpJsonValue | undefined;",
+        "};",
+        "export type OmnixdpRichTextValue = string | {",
+        "  type: \"doc\";",
+        "  content?: OmnixdpJsonValue[];",
+        "  [key: string]: OmnixdpJsonValue | undefined;",
+        "};",
+        "export type OmnixdpDataTreeNode<TData> = {",
+        "  id?: string;",
+        "  data: TData;",
+        "  children?: OmnixdpDataTreeNode<TData>[];",
+        "  __fieldMeta?: Record<string, unknown>;",
+        "};",
+        "export type OmnixdpDataTreeValue<TData, TAggregation = Record<string, number>> = {",
+        "  nodes: OmnixdpDataTreeNode<TData>[];",
+        "  aggregation?: TAggregation & { children?: number };",
+        "};"
+    ].join("\n");
+}
+function renderModelTypes(prefix, suffix, models) {
+    const typeBlocks = models.flatMap((model) => {
+        const typeName = modelTypeName(prefix, model);
+        return [
+            `export type ${typeName} = ${renderObjectType(model.fields, 0)};`
+        ];
+    });
+    const mapName = `${prefix}${suffix}`;
+    const mapLines = [
+        `export type ${mapName} = {`,
+        ...models.map((model) => `  ${quoteKey(model.apiIdentifier)}: ${modelTypeName(prefix, model)};`),
+        "};"
+    ];
+    return [...typeBlocks, mapLines.join("\n")].join("\n\n");
+}
+function renderConvenienceAliases(schema) {
+    const lines = [];
+    if (schema.cms.contentTypes.length > 0) {
+        lines.push("export type CmsDeliveryEntry<TApiIdentifier extends keyof CmsContentTypes> = DeliveryEntry<CmsContentTypes[TApiIdentifier]>;");
+    }
+    if (schema.cms.taxonomyTypes.length > 0) {
+        lines.push("export type CmsTaxonomyResponse<TApiIdentifier extends keyof CmsTaxonomyTypes> = DeliveryTaxonomyResponse & {", "  tree: Array<DeliveryTaxonomyResponse[\"tree\"][number] & { data?: CmsTaxonomyTypes[TApiIdentifier] | null }>;", "};");
+    }
+    if (schema.businessObjects.dataTypes.length > 0) {
+        lines.push("export type BusinessObjectDataObject<TApiIdentifier extends keyof BusinessObjectDataTypes> = {", "  id: string;", "  data: BusinessObjectDataTypes[TApiIdentifier];", "  [key: string]: unknown;", "};");
+    }
+    if (schema.ratingsAndReviews.dataTypes.length > 0) {
+        lines.push("export type RatingsReviewDataObject<TApiIdentifier extends keyof RatingsReviewDataTypes> = {", "  id: string;", "  data: RatingsReviewDataTypes[TApiIdentifier];", "  [key: string]: unknown;", "};");
+    }
+    if (schema.cms.contentTypes.length === 0 && schema.businessObjects.dataTypes.length === 0 && schema.ratingsAndReviews.dataTypes.length === 0) {
+        lines.push("// No models were fetched. Check the selected spaces and API tokens.");
+    }
+    return lines.join("\n");
+}
+function renderObjectType(fields, level) {
+    if (fields.length === 0)
+        return "Record<string, never>";
+    const indent = "  ".repeat(level);
+    const nextIndent = "  ".repeat(level + 1);
+    return [
+        "{",
+        ...fields.map((field) => `${nextIndent}${quoteKey(field.apiIdentifier)}${field.required ? "" : "?"}: ${renderFieldType(field, level + 1)};`),
+        `${indent}}`
+    ].join("\n");
+}
+function renderFieldType(field, level) {
+    const base = renderSingleFieldType(field, level);
+    return field.multiple && field.type !== "DATA_TREE" ? `Array<${base}>` : base;
+}
+function renderSingleFieldType(field, level) {
+    switch (field.type) {
+        case "TEXT":
+        case "MULTI_LINE_TEXT":
+        case "TITLE":
+        case "SLUG":
+        case "LINK":
+        case "URL":
+        case "MARKDOWN":
+        case "HTML":
+        case "CSS":
+        case "JAVASCRIPT":
+        case "XML":
+        case "REFERENCE":
+        case "CMS_ENTRY":
+        case "CMS_TAXONOMY":
+        case "RR_REVIEW":
+        case "RR_CATALOG":
+        case "BO_DATA_OBJECT":
+        case "BO_CATALOG":
+        case "COLOR":
+            return "string";
+        case "SELECT":
+            return optionUnion(field) ?? "string";
+        case "RADIO":
+            return `Array<${optionUnion(field) ?? "string"}>`;
+        case "NUMBER":
+        case "MONEY":
+        case "AGGREGATION":
+            return "number";
+        case "BOOLEAN":
+            return "boolean";
+        case "DATE":
+            return "string";
+        case "RICHTEXT":
+            return "OmnixdpRichTextValue";
+        case "JSON":
+            return "OmnixdpJsonValue";
+        case "MEDIA":
+            return "string | DeliveryAsset | null";
+        case "UPLOAD":
+            return "string | OmnixdpUploadValue | null";
+        case "GLOBALFIELD":
+        case "GROUP":
+        case "BLOCK":
+        case "MODULAR_BLOCK":
+            return field.fields?.length ? renderObjectType(field.fields, level) : "Record<string, unknown>";
+        case "DATA_TREE": {
+            const nested = field.fields ?? [];
+            const dataFields = nested.filter((child) => child.type !== "AGGREGATION");
+            const aggregationFields = nested.filter((child) => child.type === "AGGREGATION");
+            const dataType = dataFields.length ? renderObjectType(dataFields, level) : "Record<string, unknown>";
+            const aggregationType = aggregationFields.length ? renderObjectType(aggregationFields, level) : "Record<string, number>";
+            return `OmnixdpDataTreeValue<${dataType}, ${aggregationType}>`;
+        }
+        default:
+            return "unknown";
+    }
+}
+function optionUnion(field) {
+    const values = optionValues(field.validations);
+    if (values.length === 0)
+        return null;
+    return values.map((value) => JSON.stringify(value)).join(" | ");
+}
+function optionValues(validations) {
+    if (!validations)
+        return [];
+    const fromOptions = Array.isArray(validations.options)
+        ? validations.options
+            .map((item) => (isRecord(item) && typeof item.value === "string" ? item.value.trim() : ""))
+            .filter(Boolean)
+        : [];
+    if (fromOptions.length > 0)
+        return unique(fromOptions);
+    const fromRadioValues = Array.isArray(validations.radioValues)
+        ? validations.radioValues.map((item) => (typeof item === "string" ? item.trim() : "")).filter(Boolean)
+        : [];
+    if (fromRadioValues.length > 0)
+        return unique(fromRadioValues);
+    const labels = isRecord(validations.selectItemsLocales)
+        ? Object.values(validations.selectItemsLocales)
+            .flatMap((items) => (Array.isArray(items) ? items : []))
+            .map((item) => (typeof item === "string" ? item.trim() : ""))
+            .filter(Boolean)
+        : [];
+    return unique(labels);
+}
+function modelTypeName(prefix, model) {
+    return `${prefix}${pascalCase(model.apiIdentifier)}`;
+}
+function pascalCase(value) {
+    const words = value.split(/[^a-zA-Z0-9]+/).filter(Boolean);
+    const name = words.map((word) => `${word.charAt(0).toUpperCase()}${word.slice(1)}`).join("");
+    return name || "Model";
+}
+function quoteKey(value) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(value) ? value : JSON.stringify(value);
+}
+function unique(values) {
+    return [...new Set(values)];
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function usesDeliveryTypes(schema) {
+    return (schema.cms.contentTypes.length > 0 ||
+        schema.cms.taxonomyTypes.length > 0 ||
+        schema.businessObjects.dataTypes.some((model) => model.fields.some(fieldUsesDeliveryAsset)) ||
+        schema.ratingsAndReviews.dataTypes.some((model) => model.fields.some(fieldUsesDeliveryAsset)));
+}
+function fieldUsesDeliveryAsset(field) {
+    return field.type === "MEDIA" || Boolean(field.fields?.some(fieldUsesDeliveryAsset));
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { fetchTypegenSchema, normalizeApiUrl } from "./fetch-schema";
+export { generateTypes } from "./generate";
+export type { TypegenApplication, TypegenConfig, TypegenField, TypegenFieldKind, TypegenModel, TypegenSchema, TypegenSpace } from "./schema";

package/dist/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTypes = exports.normalizeApiUrl = exports.fetchTypegenSchema = void 0;
+var fetch_schema_1 = require("./fetch-schema");
+Object.defineProperty(exports, "fetchTypegenSchema", { enumerable: true, get: function () { return fetch_schema_1.fetchTypegenSchema; } });
+Object.defineProperty(exports, "normalizeApiUrl", { enumerable: true, get: function () { return fetch_schema_1.normalizeApiUrl; } });
+var generate_1 = require("./generate");
+Object.defineProperty(exports, "generateTypes", { enumerable: true, get: function () { return generate_1.generateTypes; } });

package/dist/schema.d.ts

@@ -0,0 +1,58 @@
+export type TypegenApplication = "cms" | "business-objects" | "ratings-and-reviews";
+export type TypegenFieldKind = "TEXT" | "MULTI_LINE_TEXT" | "TITLE" | "SLUG" | "LINK" | "URL" | "NUMBER" | "MONEY" | "BOOLEAN" | "DATE" | "RICHTEXT" | "MARKDOWN" | "JSON" | "HTML" | "CSS" | "JAVASCRIPT" | "XML" | "REFERENCE" | "MEDIA" | "GLOBALFIELD" | "SELECT" | "RADIO" | "MODULAR_BLOCK" | "BLOCK" | "COLOR" | "GROUP" | "UPLOAD" | "RR_REVIEW" | "RR_CATALOG" | "BO_DATA_OBJECT" | "BO_CATALOG" | "CMS_ENTRY" | "CMS_TAXONOMY" | "DATA_TREE" | "AGGREGATION";
+export type TypegenField = {
+    id?: string;
+    name: string;
+    apiIdentifier: string;
+    type: TypegenFieldKind | string;
+    required?: boolean;
+    multiple?: boolean;
+    localizable?: boolean;
+    deliveryApi?: boolean;
+    validations?: Record<string, unknown> | null;
+    fields?: TypegenField[];
+    globalFieldApiIdentifier?: string;
+    referenceTarget?: {
+        spaceId?: string;
+        contentTypeId?: string;
+        dataTypeId?: string;
+    };
+};
+export type TypegenModel = {
+    id: string;
+    name: string;
+    apiIdentifier: string;
+    fields: TypegenField[];
+};
+export type TypegenSpace = {
+    id: string;
+    name: string;
+    slug: string;
+};
+export type TypegenSchema = {
+    generatedAt: string;
+    sourceHash: string;
+    cms: {
+        space?: TypegenSpace;
+        contentTypes: TypegenModel[];
+        taxonomyTypes: TypegenModel[];
+    };
+    businessObjects: {
+        space?: TypegenSpace;
+        dataTypes: TypegenModel[];
+    };
+    ratingsAndReviews: {
+        space?: TypegenSpace;
+        dataTypes: TypegenModel[];
+    };
+};
+export type TypegenConfig = {
+    apiUrl: string;
+    managementToken?: string;
+    businessObjectsToken?: string;
+    ratingsAndReviewsToken?: string;
+    cmsSpace?: string;
+    boSpace?: string;
+    rrSpace?: string;
+    out?: string;
+};

package/dist/schema.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@omnixdp/typegen",
+  "version": "0.1.0",
+  "description": "TypeScript type generator for Omni xDP SDK response models.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/omnixdp/platform.git",
+    "directory": "packages/typegen"
+  },
+  "homepage": "https://github.com/omnixdp/platform/tree/main/packages/typegen#readme",
+  "bugs": {
+    "url": "https://github.com/omnixdp/platform/issues"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "omnixdp-typegen": "./dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
+    "build": "pnpm run clean && tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "prepublishOnly": "pnpm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^22.7.4",
+    "typescript": "^5.6.3",
+    "vitest": "^4.1.5"
+  },
+  "engines": {
+    "node": ">=22.16.0"
+  }
+}