@osdk/maker-import 0.1.0

package/build/cjs/index.cjs

@@ -0,0 +1,601 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var consola = require('consola');
+var fs2 = require('fs/promises');
+var path = require('path');
+var yargs = require('yargs');
+var helpers = require('yargs/helpers');
+var maker = require('@osdk/maker');
+var fs = require('fs');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var fs2__namespace = /*#__PURE__*/_interopNamespace(fs2);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+var yargs__default = /*#__PURE__*/_interopDefault(yargs);
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+
+// src/cli/main.ts
+var SIMPLE_PARAM_TYPES = {
+  string: "string",
+  integer: "integer",
+  boolean: "boolean",
+  double: "double",
+  long: "long",
+  date: "date",
+  timestamp: "timestamp",
+  attachment: "attachment",
+  marking: "marking",
+  geohash: "geohash",
+  geoshape: "geoshape",
+  mediaReference: "mediaReference",
+  decimal: "decimal"
+};
+var LIST_VARIANT_MAP = {
+  string: "stringList",
+  integer: "integerList",
+  boolean: "booleanList",
+  double: "doubleList",
+  long: "longList",
+  date: "dateList",
+  timestamp: "timestampList",
+  attachment: "attachmentList",
+  marking: "markingList",
+  geohash: "geohashList",
+  geoshape: "geoshapeList",
+  mediaReference: "mediaReferenceList",
+  decimal: "decimalList"
+};
+var STRUCT_FIELD_IR_TYPES = {
+  boolean: "boolean",
+  integer: "integer",
+  long: "long",
+  double: "double",
+  string: "string",
+  geohash: "geohash",
+  geoshape: "geoshape",
+  timestamp: "timestamp",
+  date: "date"
+};
+function mapGatewayStructFieldsToIr(dataType) {
+  const fields = dataType.structFieldTypes;
+  if (!fields) {
+    consola.consola.warn("Struct parameter type missing structFieldTypes, skipping");
+    return void 0;
+  }
+  const structFieldTypes = {};
+  for (const field of fields) {
+    const fieldType = field.dataType.type;
+    const irType = STRUCT_FIELD_IR_TYPES[fieldType];
+    if (irType) {
+      structFieldTypes[field.apiName] = {
+        type: irType,
+        [irType]: {}
+      };
+    } else if (fieldType === "object") {
+      const objectTypeApiName = field.dataType.objectTypeApiName ?? "";
+      structFieldTypes[field.apiName] = {
+        type: "objectReference",
+        objectReference: {
+          objectTypeId: objectTypeApiName
+        }
+      };
+    } else {
+      consola.consola.warn(`Skipping struct param field "${field.apiName}": unsupported type "${fieldType}"`);
+    }
+  }
+  return structFieldTypes;
+}
+function mapActionParameterType(dataType) {
+  const simpleType = SIMPLE_PARAM_TYPES[dataType.type];
+  if (simpleType !== void 0) {
+    return simpleType;
+  }
+  switch (dataType.type) {
+    case "object": {
+      const objectTypeApiName = dataType.objectTypeApiName ?? "";
+      return {
+        type: "objectReference",
+        objectReference: {
+          objectTypeId: objectTypeApiName
+        }
+      };
+    }
+    case "objectSet": {
+      const objectTypeApiName = dataType.objectTypeApiName ?? "";
+      return {
+        type: "objectSetRid",
+        objectSetRid: {
+          objectTypeId: objectTypeApiName
+        }
+      };
+    }
+    case "interfaceObject": {
+      const interfaceApiName = dataType.interfaceApiName ?? "";
+      return {
+        type: "interfaceReference",
+        interfaceReference: {
+          interfaceTypeRid: interfaceApiName
+        }
+      };
+    }
+    case "array": {
+      const subType = dataType.subType;
+      if (!subType) {
+        consola.consola.warn("Array parameter type missing subType, skipping");
+        return void 0;
+      }
+      const listVariant = LIST_VARIANT_MAP[subType.type];
+      if (listVariant !== void 0) {
+        return listVariant;
+      }
+      if (subType.type === "object") {
+        const objectTypeApiName = subType.objectTypeApiName ?? "";
+        return {
+          type: "objectReferenceList",
+          objectReferenceList: {
+            objectTypeId: objectTypeApiName
+          }
+        };
+      }
+      if (subType.type === "interfaceObject") {
+        const interfaceApiName = subType.interfaceApiName ?? "";
+        return {
+          type: "interfaceReferenceList",
+          interfaceReferenceList: {
+            interfaceTypeRid: interfaceApiName
+          }
+        };
+      }
+      if (subType.type === "struct") {
+        const structFields = mapGatewayStructFieldsToIr(subType);
+        if (!structFields) return void 0;
+        return {
+          type: "structList",
+          structList: {
+            structFieldTypes: structFields
+          }
+        };
+      }
+      consola.consola.warn(`Skipping array parameter with unsupported subType: ${subType.type}`);
+      return void 0;
+    }
+    case "struct": {
+      const structFields = mapGatewayStructFieldsToIr(dataType);
+      if (!structFields) return void 0;
+      return {
+        type: "struct",
+        struct: {
+          structFieldTypes: structFields
+        }
+      };
+    }
+    case "vector":
+      consola.consola.warn("Skipping vector parameter type: no maker equivalent");
+      return void 0;
+    case "objectType":
+      return "objectTypeReference";
+    default:
+      consola.consola.warn(`Skipping unknown parameter type: ${dataType.type}`);
+      return void 0;
+  }
+}
+
+// src/generate/utils.ts
+function withoutNamespace(apiName) {
+  const lastDot = apiName.lastIndexOf(".");
+  if (lastDot === -1) {
+    return apiName;
+  }
+  return apiName.substring(lastDot + 1);
+}
+function fullCamel(apiName) {
+  return camel(apiName.replace(/\./g, "-"));
+}
+function camel(str) {
+  if (!str) {
+    return str;
+  }
+  let result = str.replace(/[-_]+(.)?/g, (_, c) => c ? c.toUpperCase() : "");
+  result = result.charAt(0).toLowerCase() + result.slice(1);
+  return result;
+}
+
+// src/generate/convertActionType.ts
+function convertActionType(action) {
+  const parameters = [];
+  for (const [paramId, paramV2] of Object.entries(action.parameters)) {
+    const mappedType = mapActionParameterType(paramV2.dataType);
+    if (!mappedType) {
+      consola.consola.warn(`Skipping parameter "${paramId}" on action "${action.apiName}": unsupported type "${paramV2.dataType.type}"`);
+      continue;
+    }
+    parameters.push({
+      id: paramId,
+      displayName: paramV2.displayName ?? paramId,
+      type: mappedType,
+      validation: {
+        required: paramV2.required
+      }
+    });
+  }
+  const shortName = withoutNamespace(action.apiName);
+  return {
+    __type: maker.OntologyEntityTypeEnum.ACTION_TYPE,
+    apiName: action.apiName,
+    displayName: action.displayName ?? shortName,
+    status: mapActionStatus(action.status),
+    rules: [],
+    parameters
+  };
+}
+function mapActionStatus(status) {
+  switch (status) {
+    case "ACTIVE":
+      return "active";
+    case "EXPERIMENTAL":
+      return "experimental";
+    default:
+      return "active";
+  }
+}
+function mapPropertyType(dataType) {
+  switch (dataType.type) {
+    case "string":
+      return {
+        type: "string"
+      };
+    case "integer":
+      return {
+        type: "integer"
+      };
+    case "boolean":
+      return {
+        type: "boolean"
+      };
+    case "double":
+      return {
+        type: "double"
+      };
+    case "float":
+      return {
+        type: "float"
+      };
+    case "long":
+      return {
+        type: "long"
+      };
+    case "short":
+      return {
+        type: "short"
+      };
+    case "byte":
+      return {
+        type: "byte"
+      };
+    case "date":
+      return {
+        type: "date"
+      };
+    case "timestamp":
+      return {
+        type: "timestamp"
+      };
+    case "decimal":
+      return {
+        type: "decimal"
+      };
+    case "attachment":
+      return {
+        type: "attachment"
+      };
+    case "geopoint":
+      return {
+        type: "geopoint"
+      };
+    case "geoshape":
+      return {
+        type: "geoshape"
+      };
+    case "mediaReference":
+      return {
+        type: "mediaReference"
+      };
+    case "geotimeSeriesReference":
+      return {
+        type: "geotimeSeries"
+      };
+    case "array": {
+      const subType = dataType.subType;
+      if (!subType) {
+        consola.consola.warn("Array type missing subType, skipping");
+        return void 0;
+      }
+      const inner = mapPropertyType(subType);
+      if (!inner) {
+        return void 0;
+      }
+      return {
+        type: inner.type,
+        array: true
+      };
+    }
+    // We don't support structs or markings here. It should have no influence on importing functionality
+    default:
+      return void 0;
+  }
+}
+
+// src/generate/convertSharedPropertyType.ts
+function convertSharedPropertyType(spt) {
+  const mapped = mapPropertyType(spt.dataType);
+  if (!mapped) {
+    consola.consola.warn(`Skipping shared property type "${spt.apiName}": unsupported type "${spt.dataType.type}"`);
+    return void 0;
+  }
+  return {
+    __type: maker.OntologyEntityTypeEnum.SHARED_PROPERTY_TYPE,
+    apiName: spt.apiName,
+    nonNameSpacedApiName: withoutNamespace(spt.apiName),
+    displayName: spt.displayName ?? withoutNamespace(spt.apiName),
+    type: mapped.type,
+    array: mapped.array,
+    description: spt.description
+  };
+}
+
+// src/generate/convertInterfaceType.ts
+function convertInterfaceType(iface, allInterfaces) {
+  const shortName = withoutNamespace(iface.apiName);
+  const propertiesV2 = {};
+  const propertiesV3 = {};
+  for (const [sptApiName, sptDef] of Object.entries(iface.properties)) {
+    const converted = convertSharedPropertyType({
+      apiName: sptApiName,
+      displayName: sptDef.displayName,
+      description: sptDef.description,
+      dataType: sptDef.dataType
+    });
+    if (converted) {
+      const entry = {
+        sharedPropertyType: converted,
+        required: true
+      };
+      propertiesV2[sptApiName] = entry;
+      propertiesV3[withoutNamespace(sptApiName)] = entry;
+    }
+  }
+  const extendsInterfaces = [];
+  for (const extApiName of iface.extendsInterfaces) {
+    const extIface = allInterfaces[extApiName];
+    if (extIface) {
+      extendsInterfaces.push(convertInterfaceType(extIface, allInterfaces));
+    }
+  }
+  return {
+    __type: maker.OntologyEntityTypeEnum.INTERFACE_TYPE,
+    apiName: iface.apiName,
+    displayMetadata: {
+      displayName: iface.displayName ?? shortName,
+      description: iface.description ?? shortName
+    },
+    extendsInterfaces,
+    links: [],
+    status: {
+      type: "active",
+      active: {}
+    },
+    propertiesV2,
+    propertiesV3,
+    searchable: true
+  };
+}
+function convertObjectType(fullMetadata) {
+  const obj = fullMetadata.objectType;
+  const properties = [];
+  for (const [propApiName, propV2] of Object.entries(obj.properties)) {
+    const mapped = mapPropertyType(propV2.dataType);
+    if (!mapped) {
+      consola.consola.warn(`Skipping property "${propApiName}" on object "${obj.apiName}": unsupported type "${propV2.dataType.type}"`);
+      continue;
+    }
+    const prop = {
+      apiName: propApiName,
+      displayName: propV2.displayName ?? propApiName,
+      type: mapped.type
+    };
+    if (mapped.array) {
+      prop.array = true;
+    }
+    properties.push(prop);
+  }
+  const shortName = withoutNamespace(obj.apiName);
+  return {
+    __type: maker.OntologyEntityTypeEnum.OBJECT_TYPE,
+    apiName: obj.apiName,
+    displayName: obj.displayName ?? shortName,
+    pluralDisplayName: (obj.displayName ?? shortName) + "s",
+    primaryKeyPropertyApiName: obj.primaryKey,
+    titlePropertyApiName: obj.titleProperty,
+    properties,
+    description: obj.description,
+    visibility: obj.visibility,
+    status: mapObjectStatus(obj.status)
+  };
+}
+function mapObjectStatus(status) {
+  switch (status) {
+    case "ACTIVE":
+      return "active";
+    case "EXPERIMENTAL":
+      return "experimental";
+    default:
+      return "active";
+  }
+}
+
+// src/generate/writeImportedOntology.ts
+var TYPE_NAME_MAP = {
+  [maker.OntologyEntityTypeEnum.OBJECT_TYPE]: "ObjectType",
+  [maker.OntologyEntityTypeEnum.ACTION_TYPE]: "ActionType",
+  [maker.OntologyEntityTypeEnum.INTERFACE_TYPE]: "InterfaceType",
+  [maker.OntologyEntityTypeEnum.SHARED_PROPERTY_TYPE]: "SharedPropertyType"
+};
+var DIR_NAME_MAP = {
+  [maker.OntologyEntityTypeEnum.OBJECT_TYPE]: "object-types",
+  [maker.OntologyEntityTypeEnum.ACTION_TYPE]: "action-types",
+  [maker.OntologyEntityTypeEnum.INTERFACE_TYPE]: "interface-types",
+  [maker.OntologyEntityTypeEnum.SHARED_PROPERTY_TYPE]: "shared-property-types"
+};
+function resolveVarNames(apiNames) {
+  const shortNames = apiNames.map((n) => camel(withoutNamespace(n)));
+  const counts = /* @__PURE__ */ new Map();
+  for (const name of shortNames) {
+    counts.set(name, (counts.get(name) ?? 0) + 1);
+  }
+  const resolved = apiNames.map((apiName, i) => {
+    if (counts.get(shortNames[i]) > 1) {
+      return fullCamel(apiName);
+    }
+    return shortNames[i];
+  });
+  const finalNames = [];
+  const used = /* @__PURE__ */ new Map();
+  for (const name of resolved) {
+    const count = used.get(name) ?? 0;
+    finalNames.push(count === 0 ? name : `${name}${count}`);
+    used.set(name, count + 1);
+  }
+  return finalNames;
+}
+function writeImportedOntology(metadata, outputDir) {
+  const codegenDir = path__namespace.resolve(outputDir, "codegen");
+  for (const dirName of Object.values(DIR_NAME_MAP)) {
+    const dirPath = path__namespace.join(codegenDir, dirName);
+    if (fs__namespace.existsSync(dirPath)) {
+      fs__namespace.rmSync(dirPath, {
+        recursive: true,
+        force: true
+      });
+    }
+    fs__namespace.mkdirSync(dirPath, {
+      recursive: true
+    });
+  }
+  const entries = [];
+  for (const [_apiName, spt] of Object.entries(metadata.sharedPropertyTypes)) {
+    const converted = convertSharedPropertyType(spt);
+    if (converted) {
+      entries.push({
+        apiName: converted.apiName,
+        entityType: maker.OntologyEntityTypeEnum.SHARED_PROPERTY_TYPE,
+        entity: converted
+      });
+    }
+  }
+  for (const [_apiName, iface] of Object.entries(metadata.interfaceTypes)) {
+    const converted = convertInterfaceType(iface, metadata.interfaceTypes);
+    entries.push({
+      apiName: converted.apiName,
+      entityType: maker.OntologyEntityTypeEnum.INTERFACE_TYPE,
+      entity: converted
+    });
+  }
+  for (const [_apiName, objFull] of Object.entries(metadata.objectTypes)) {
+    const converted = convertObjectType(objFull);
+    entries.push({
+      apiName: converted.apiName,
+      entityType: maker.OntologyEntityTypeEnum.OBJECT_TYPE,
+      entity: converted
+    });
+  }
+  for (const [_apiName, action] of Object.entries(metadata.actionTypes)) {
+    const converted = convertActionType(action);
+    entries.push({
+      apiName: converted.apiName,
+      entityType: maker.OntologyEntityTypeEnum.ACTION_TYPE,
+      entity: converted
+    });
+  }
+  const varNames = resolveVarNames(entries.map((e) => e.apiName));
+  const topLevelExports = [];
+  for (let i = 0; i < entries.length; i++) {
+    writeEntityFile(codegenDir, entries[i].entityType, entries[i].entity, varNames[i], topLevelExports);
+  }
+  if (topLevelExports.length > 0) {
+    const indexContent = topLevelExports.join("\n") + "\n";
+    const indexPath = path__namespace.join(outputDir, "index.ts");
+    fs__namespace.writeFileSync(indexPath, indexContent, {
+      flag: "w"
+    });
+  }
+}
+function writeEntityFile(codegenDir, entityType, entity, varName, topLevelExports) {
+  const typeName = TYPE_NAME_MAP[entityType];
+  const dirName = DIR_NAME_MAP[entityType];
+  const entityJSON = JSON.stringify(entity, null, 2).replace(/("__type"\s*:\s*)"([^"]*)"/g, (_, prefix, value) => `${prefix}OntologyEntityTypeEnum.${value}`);
+  const content = `import { wrapWithProxy, OntologyEntityTypeEnum } from '@osdk/maker';
+import type { ${typeName} } from '@osdk/maker';
+
+/** @type {import('@osdk/maker').${typeName}} */
+const ${varName}_base: ${typeName} = ${entityJSON} as unknown as ${typeName};
+
+export const ${varName}: ${typeName} = wrapWithProxy(${varName}_base);
+`;
+  const filePath = path__namespace.join(codegenDir, dirName, `${varName}.ts`);
+  fs__namespace.writeFileSync(filePath, content, {
+    flag: "w"
+  });
+  topLevelExports.push(`export { ${varName} } from "./codegen/${dirName}/${varName}.js";`);
+}
+
+// src/cli/main.ts
+async function main(args = process.argv) {
+  const commandLineOpts = await yargs__default.default(helpers.hideBin(args)).version("0.1.0").wrap(Math.min(150, yargs__default.default().terminalWidth())).strict().help().options({
+    input: {
+      alias: "i",
+      describe: "Path to OntologyFullMetadata JSON file",
+      type: "string",
+      demandOption: true,
+      coerce: path__namespace.resolve
+    },
+    output: {
+      alias: "o",
+      describe: "Output directory for generated TypeScript files",
+      type: "string",
+      default: "./generated-imports",
+      coerce: path__namespace.resolve
+    }
+  }).parseAsync();
+  consola.consola.info(`Reading OntologyFullMetadata from ${commandLineOpts.input}`);
+  const jsonContent = await fs2__namespace.readFile(commandLineOpts.input, "utf-8");
+  const metadata = JSON.parse(jsonContent);
+  consola.consola.info(`Writing generated imports to ${commandLineOpts.output}`);
+  writeImportedOntology(metadata, commandLineOpts.output);
+  consola.consola.success(`Generated import files in ${commandLineOpts.output}`);
+}
+
+exports.default = main;
+exports.writeImportedOntology = writeImportedOntology;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map