@stripe/extensibility-custom-objects-tools 0.40.0

package/dist/build/cli.js

@@ -0,0 +1,991 @@
+#!/usr/bin/env node
+
+// src/build/cli.ts
+import { _createLogger } from "@stripe/extensibility-tool-utils";
+
+// src/build/build.ts
+import { mkdir, readdir, readFile as readFile2, writeFile } from "fs/promises";
+import { dirname, join, relative } from "path";
+
+// src/transformer/transform.ts
+import { readFile } from "fs/promises";
+import { Project } from "ts-morph";
+
+// src/transformer/visitors.ts
+import { Node, SyntaxKind } from "ts-morph";
+
+// src/transformer/metadata.ts
+function toSnakeCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/([0-9])([A-Z])/g, "$1_$2").replace(/([A-Z])([A-Z][a-z])/g, "$1_$2").toLowerCase();
+}
+
+// src/transformer/classify-fields.ts
+function classifyJsonSchemaProperty(schema, typeName) {
+  const { type, format } = schema;
+  if (type === "string") {
+    if (format === "date-time") return { kind: "datetime" };
+    if (format === "decimal") return { kind: "decimal" };
+    if (schema.enum !== void 0 && schema.enum.length > 0) {
+      return { kind: "enum", typeName: typeName ?? "UnknownEnum" };
+    }
+    return { kind: "primitive" };
+  }
+  if (type === "array" && schema.items) {
+    const element = classifyJsonSchemaProperty(schema.items, typeName);
+    return { kind: "array", element };
+  }
+  if (type === "object") {
+    if (schema.additionalProperties !== void 0 && typeof schema.additionalProperties === "object" && (!schema.properties || Object.keys(schema.properties).length === 0)) {
+      const value = classifyJsonSchemaProperty(schema.additionalProperties, typeName);
+      return { kind: "map", value };
+    }
+    if (schema.properties && Object.keys(schema.properties).length > 0) {
+      return { kind: "interface", typeName: typeName ?? "UnknownInterface" };
+    }
+    return { kind: "primitive" };
+  }
+  return { kind: "primitive" };
+}
+function classifyObjectSchema(schema, prefix) {
+  const fields = {};
+  const optionality = {};
+  const nestedSchemas = [];
+  const requiredSet = new Set(schema.required ?? []);
+  const properties = schema.properties ?? {};
+  for (const [propName, propSchema] of Object.entries(properties)) {
+    const nestedTypeName = `${prefix}_${propName}`;
+    const classification = classifyJsonSchemaProperty(propSchema, nestedTypeName);
+    fields[propName] = classification;
+    optionality[propName] = !requiredSet.has(propName);
+    collectNestedSchemas(propSchema, nestedTypeName, nestedSchemas);
+  }
+  return { fields, optionality, nestedSchemas };
+}
+function collectNestedSchemas(schema, typeName, results) {
+  if (schema.type === "object" && schema.properties && Object.keys(schema.properties).length > 0) {
+    results.push({ typeName, schema });
+    for (const [propName, propSchema] of Object.entries(schema.properties)) {
+      collectNestedSchemas(propSchema, `${typeName}_${propName}`, results);
+    }
+  }
+  if (schema.type === "array" && schema.items) {
+    collectNestedSchemas(schema.items, typeName, results);
+  }
+  if (schema.type === "object" && typeof schema.additionalProperties === "object") {
+    collectNestedSchemas(schema.additionalProperties, typeName, results);
+  }
+}
+
+// src/transformer/generate-descriptors.ts
+var toSchemaNode = (schema) => (
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-unsafe-type-assertion -- single centralized cast boundary
+  schema
+);
+function getFieldTransform(cls) {
+  switch (cls.kind) {
+    case "primitive":
+      return "_identity";
+    case "decimal":
+      return "_translateDecimal";
+    case "datetime":
+      return "_translateDateTime";
+    case "enum":
+      return "_identity";
+    case "interface":
+      return `_translateShape(() => ${cls.typeName}Descriptor)`;
+    case "array":
+      return `_translateArray(${getFieldTransform(cls.element)})`;
+    case "map":
+      return `_translateMap(_identity, ${getFieldTransform(cls.value)})`;
+    default: {
+      const _exhaustive = cls;
+      return _exhaustive;
+    }
+  }
+}
+function wrapTransform(expr, isOptional) {
+  if (isOptional) return expr;
+  return expr === "_identity" ? "_required()" : `_required(${expr})`;
+}
+function generateShapeDescriptor(descriptorName, strategyType, classified, propertyNameMap) {
+  const fieldEntries = Object.entries(classified.fields).map(([schemaKey, cls]) => {
+    const isOptional = classified.optionality[schemaKey] ?? true;
+    const transformExpr = wrapTransform(getFieldTransform(cls), isOptional);
+    const tsKey = propertyNameMap?.[schemaKey] ?? schemaKey;
+    const wireClause = tsKey !== schemaKey ? `wire: '${schemaKey}', ` : "";
+    return `  { ${wireClause}type: '${tsKey}', transform: ${transformExpr} },`;
+  });
+  return [
+    `const ${descriptorName} = new _ShapeDescriptor<${strategyType}>('${descriptorName}', [`,
+    ...fieldEntries,
+    `]);`
+  ].join("\n");
+}
+function emitDescriptorsForSchema(schema, descriptorName, prefix, strategyType, code, propertyNameMap) {
+  const classified = classifyObjectSchema(schema, prefix);
+  for (const nested of classified.nestedSchemas) {
+    const nestedClassified = classifyObjectSchema(nested.schema, nested.typeName);
+    code.push("");
+    code.push(
+      generateShapeDescriptor(
+        `${nested.typeName}Descriptor`,
+        "typeof _ProtoWireToType | typeof _TypeToProtoWire",
+        nestedClassified
+        // Nested schemas don't get a property name map — they use schema keys directly.
+        // The mapping only applies at the top-level surface boundary.
+      )
+    );
+  }
+  code.push("");
+  code.push(
+    generateShapeDescriptor(descriptorName, strategyType, classified, propertyNameMap)
+  );
+}
+function generateDescriptors(input) {
+  const code = [];
+  const descriptorNames = {
+    fields: null,
+    actions: {}
+  };
+  const fieldsSchema = toSchemaNode(input.fieldsSchema);
+  if (fieldsSchema?.properties && Object.keys(fieldsSchema.properties).length > 0) {
+    const fieldsDescriptorName = `${input.className}_FieldsDescriptor`;
+    emitDescriptorsForSchema(
+      fieldsSchema,
+      fieldsDescriptorName,
+      `${input.className}_Fields`,
+      "typeof _ProtoWireToType",
+      code,
+      input.fieldsPropertyNameMap
+    );
+    descriptorNames.fields = fieldsDescriptorName;
+  }
+  for (const [apiName, action] of Object.entries(input.actions)) {
+    const actionDescriptors = {
+      input: null,
+      output: null
+    };
+    const inputSchema = toSchemaNode(action.inputSchema);
+    const outputSchema = toSchemaNode(action.outputSchema);
+    if (inputSchema?.properties && Object.keys(inputSchema.properties).length > 0) {
+      const inputDescriptorName = `${input.className}_${apiName}_InputDescriptor`;
+      emitDescriptorsForSchema(
+        inputSchema,
+        inputDescriptorName,
+        `${input.className}_${apiName}_Input`,
+        "typeof _ProtoWireToType",
+        code,
+        action.inputPropertyNameMap
+      );
+      actionDescriptors.input = inputDescriptorName;
+    }
+    if (outputSchema?.properties && Object.keys(outputSchema.properties).length > 0) {
+      const outputDescriptorName = `${input.className}_${apiName}_OutputDescriptor`;
+      emitDescriptorsForSchema(
+        outputSchema,
+        outputDescriptorName,
+        `${input.className}_${apiName}_Output`,
+        "typeof _TypeToProtoWire",
+        code,
+        action.outputPropertyNameMap
+      );
+      actionDescriptors.output = outputDescriptorName;
+    }
+    descriptorNames.actions[apiName] = actionDescriptors;
+  }
+  return { code, descriptorNames };
+}
+
+// src/transformer/visitors.ts
+function getDecoratorMetadata(decorator) {
+  const expression = decorator.getExpression();
+  if (Node.isIdentifier(expression)) {
+    return { name: expression.getText() };
+  }
+  return null;
+}
+function hasCustomObjectDecorator(classDecl) {
+  return classDecl.getDecorators().some((decorator) => {
+    const metadata = getDecoratorMetadata(decorator);
+    return metadata?.name === "CustomObject";
+  });
+}
+function extractArgType(method) {
+  const params = method.getParameters();
+  if (params.length === 0) {
+    return "{}";
+  }
+  const firstParam = params[0];
+  if (!firstParam) {
+    return "{}";
+  }
+  const typeNode = firstParam.getTypeNode();
+  if (typeNode) {
+    return typeNode.getText();
+  }
+  const paramType = firstParam.getType();
+  return paramType.getText() || "unknown";
+}
+function extractReturnType(method) {
+  const returnTypeNode = method.getReturnTypeNode();
+  if (returnTypeNode) {
+    return returnTypeNode.getText();
+  }
+  const returnType = method.getReturnType();
+  const text = returnType.getText();
+  if (text === "void" || text === "undefined") {
+    return "void";
+  }
+  return text || "void";
+}
+function extractTSDocTag(node, tagName) {
+  const jsDocs = node.getJsDocs();
+  const lastDoc = jsDocs.at(-1);
+  if (!lastDoc) return void 0;
+  const tag = lastDoc.getTags().find((t) => t.getTagName() === tagName);
+  if (!tag) return void 0;
+  const text = tag.getCommentText()?.trim();
+  if (!text) return void 0;
+  return text;
+}
+function extractApiNameFromAction(method, fallbackMethodName) {
+  const tagValue = extractTSDocTag(method, "apiName");
+  if (tagValue) return tagValue;
+  return toSnakeCase(fallbackMethodName);
+}
+function extractActionMetadata(method) {
+  const decorators = method.getDecorators();
+  for (const decorator of decorators) {
+    const metadata = getDecoratorMetadata(decorator);
+    if (!metadata) {
+      continue;
+    }
+    if (metadata.name === "Action") {
+      const methodName = method.getName();
+      const argType = extractArgType(method);
+      const returnType = extractReturnType(method);
+      const apiName = extractApiNameFromAction(method, methodName);
+      const result = {
+        methodName,
+        argType,
+        returnType,
+        apiName
+      };
+      return result;
+    }
+  }
+  return null;
+}
+function extractApiName(classDecl) {
+  const tagValue = extractTSDocTag(classDecl, "apiName");
+  if (tagValue) return tagValue;
+  const className = classDecl.getName();
+  if (!className) {
+    throw new Error(
+      "Anonymous @CustomObject class must have an @apiName TSDoc tag. Either name the class or add /** @apiName my_name */ above the decorator."
+    );
+  }
+  return toSnakeCase(className);
+}
+function extractPlatformMetadata(classDecl) {
+  const apiName = extractApiName(classDecl);
+  const actions = {
+    instance: {}
+  };
+  for (const method of classDecl.getInstanceMethods()) {
+    const actionMetadata = extractActionMetadata(method);
+    if (actionMetadata) {
+      actions.instance[actionMetadata.methodName] = actionMetadata;
+    }
+  }
+  return {
+    apiName,
+    actions
+  };
+}
+function injectPlatformMetadata(classDecl, metadata) {
+  const existingProperty = classDecl.getStaticProperty("__platformMeta__");
+  if (existingProperty) {
+    existingProperty.remove();
+  }
+  const metadataJson = JSON.stringify(metadata, null, 2);
+  classDecl.insertProperty(0, {
+    isStatic: true,
+    name: "__platformMeta__",
+    initializer: metadataJson
+  });
+}
+function injectConstructorProxy(classDecl) {
+  let constructor = classDecl.getConstructors()[0];
+  const hasBaseClass = classDecl.getExtends() !== void 0;
+  if (!constructor) {
+    const statements = hasBaseClass ? ["super(id);"] : [];
+    constructor = classDecl.addConstructor({
+      parameters: [{ name: "id", type: "string", hasQuestionToken: true }],
+      statements
+    });
+  }
+  const returnStatements = constructor.getDescendantsOfKind(SyntaxKind.ReturnStatement);
+  if (returnStatements.length > 0) {
+    throw new Error(
+      `Custom object "${classDecl.getName() ?? "anonymous"}" has explicit return statements in its constructor. Custom object constructors cannot return values \u2014 the proxy is returned automatically.`
+    );
+  }
+  constructor.insertStatements(constructor.getStatements().length, [
+    "if (!this.fields) { (this as any).fields = {}; }",
+    "return _createInstanceProxy(this).proxy;"
+  ]);
+}
+function injectAutoSave(method) {
+  method.addStatements(["if (__hasPendingChanges(this)) {", "  __queueSave(this);", "}"]);
+}
+var CUSTOM_OBJECTS_IMPORTS = [
+  "_createInstanceProxy",
+  "__hasPendingChanges",
+  "__queueSave",
+  "_registerClass",
+  "_getProxyState",
+  "_getSlatedUpdates",
+  "_clearSlatedUpdates",
+  "_buildMethodResponse"
+];
+var STDLIB_IMPORTS = [
+  "_ShapeDescriptor",
+  "_apply",
+  "_ProtoWireToType",
+  "_TypeToProtoWire",
+  "_identity",
+  "_required",
+  "_translateDateTime",
+  "_translateDecimal",
+  "_translateShape",
+  "_translateArray",
+  "_translateMap",
+  "_isPromiseLike"
+];
+function injectRuntimeImports(sourceFile, hasDescriptors = false) {
+  const existingRuntimeCoImport = sourceFile.getImportDeclarations().find(
+    (decl) => decl.getModuleSpecifierValue() === "@stripe/extensibility-custom-objects" && !decl.isTypeOnly()
+  );
+  if (existingRuntimeCoImport) {
+    const namedImports = existingRuntimeCoImport.getNamedImports().map((ni) => ni.getName());
+    for (const needed of CUSTOM_OBJECTS_IMPORTS) {
+      if (!namedImports.includes(needed)) {
+        existingRuntimeCoImport.addNamedImport(needed);
+      }
+    }
+  } else {
+    sourceFile.insertImportDeclaration(0, {
+      moduleSpecifier: "@stripe/extensibility-custom-objects",
+      namedImports: [...CUSTOM_OBJECTS_IMPORTS]
+    });
+  }
+  if (hasDescriptors) {
+    const existingRuntimeStdlibImport = sourceFile.getImportDeclarations().find(
+      (decl) => decl.getModuleSpecifierValue() === "@stripe/extensibility-sdk/stdlib" && !decl.isTypeOnly()
+    );
+    if (existingRuntimeStdlibImport) {
+      const namedImports = existingRuntimeStdlibImport.getNamedImports().map((ni) => ni.getName());
+      for (const needed of STDLIB_IMPORTS) {
+        if (!namedImports.includes(needed)) {
+          existingRuntimeStdlibImport.addNamedImport(needed);
+        }
+      }
+    } else {
+      sourceFile.insertImportDeclaration(0, {
+        moduleSpecifier: "@stripe/extensibility-sdk/stdlib",
+        namedImports: [...STDLIB_IMPORTS]
+      });
+    }
+  }
+}
+var KNOWN_DECORATOR_NAMES = /* @__PURE__ */ new Set(["CustomObject", "CustomFields", "Action"]);
+function removeDecorators(classDecl) {
+  for (const decorator of classDecl.getDecorators()) {
+    const metadata = getDecoratorMetadata(decorator);
+    if (metadata?.name && KNOWN_DECORATOR_NAMES.has(metadata.name)) {
+      decorator.remove();
+    }
+  }
+  for (const method of classDecl.getMethods()) {
+    for (const decorator of method.getDecorators()) {
+      const metadata = getDecoratorMetadata(decorator);
+      if (metadata?.name && KNOWN_DECORATOR_NAMES.has(metadata.name)) {
+        decorator.remove();
+      }
+    }
+  }
+  for (const property of classDecl.getProperties()) {
+    for (const decorator of property.getDecorators()) {
+      const metadata = getDecoratorMetadata(decorator);
+      if (metadata?.name && KNOWN_DECORATOR_NAMES.has(metadata.name)) {
+        decorator.remove();
+      }
+    }
+  }
+}
+function removeDecoratorImports(sourceFile) {
+  const imports = sourceFile.getImportDeclarations();
+  for (const importDecl of imports) {
+    const moduleSpecifier = importDecl.getModuleSpecifierValue();
+    if (moduleSpecifier === "@stripe/extensibility-custom-objects") {
+      const namedImports = importDecl.getNamedImports();
+      for (const namedImport of namedImports) {
+        const importName = namedImport.getName();
+        if (KNOWN_DECORATOR_NAMES.has(importName)) {
+          namedImport.remove();
+        }
+      }
+      if (importDecl.getNamedImports().length === 0) {
+        importDecl.remove();
+      }
+    }
+  }
+}
+function generateInstanceMethodTypeMap(metadata) {
+  const entries = Object.entries(metadata.actions.instance);
+  if (entries.length === 0) {
+    return "type InstanceMethodTypeMap = Record<string, never>;";
+  }
+  const typeEntries = entries.map(([methodName, action]) => {
+    return `  ${methodName}: { argType: ${action.argType}; returnType: ${action.returnType} };`;
+  });
+  return `type InstanceMethodTypeMap = {
+${typeEntries.join("\n")}
+};`;
+}
+function generateWrapperClass(metadata, className, schemaData) {
+  if (schemaData) {
+    return generateWireConvertingWrapperClass(metadata, className, schemaData);
+  }
+  return generateLegacyWrapperClass(metadata, className);
+}
+function generateWireConvertingWrapperClass(metadata, className, schemaData) {
+  const wrapperName = `${className}Logic`;
+  const descriptorInput = {
+    className,
+    fieldsSchema: schemaData.fieldsSchema,
+    fieldsPropertyNameMap: schemaData.fieldsPropertyNameMap,
+    actions: Object.fromEntries(
+      Object.entries(schemaData.actions).map(([apiName, actionSchema]) => [
+        apiName,
+        {
+          apiName,
+          inputSchema: actionSchema.inputSchema,
+          outputSchema: actionSchema.outputSchema,
+          inputPropertyNameMap: actionSchema.inputPropertyNameMap,
+          outputPropertyNameMap: actionSchema.outputPropertyNameMap
+        }
+      ])
+    )
+  };
+  const descriptorResult = generateDescriptors(descriptorInput);
+  const descriptorCode = descriptorResult.code.join("\n");
+  const switchCases = buildWireConvertingSwitchCases(metadata, descriptorResult);
+  const assignLine = descriptorResult.descriptorNames.fields ? [
+    `      const native = _apply(${descriptorResult.descriptorNames.fields}, _ProtoWireToType, wireRecord);`,
+    `      Object.assign(instance.fields, native);`
+  ].join("\n") : `      Object.assign(instance.fields, wireRecord);`;
+  const hydrateBody = assignLine;
+  const parts = [];
+  if (descriptorCode.trim().length > 0) {
+    parts.push("");
+    parts.push("// Wire conversion descriptors");
+    parts.push(descriptorCode);
+  }
+  const actionEntries = Object.values(metadata.actions.instance);
+  const methodNameUnion = actionEntries.map((a) => `"${a.apiName}"`).join(" | ") || "never";
+  parts.push(`
+interface ${wrapperName}Request {
+  objectRecord?: Record<string, unknown>;
+  methodName: ${methodNameUnion};
+  methodArgs?: Record<string, unknown>;
+}
+
+class ${wrapperName} {
+  // Fresh instance per executeMethod call to prevent state leakage between invocations.
+  // The platform may call executeMethod for different object records on the same module.
+  private createInstance(): ${className} {
+    return new ${className}();
+  }
+
+  private hydrate(instance: ${className}, wireRecord: Record<string, unknown>): void {
+${hydrateBody}
+  }
+
+  private hydrateObjectRecord(instance: ${className}, objectRecord: Record<string, unknown>): void {
+    // Extract the inner fields map from the ObjectRecord proto.
+    // The proto shape is { id, object_definition_id, fields: {...}, created, updated, object }.
+    const fields = objectRecord.fields;
+    if (typeof fields !== 'object' || fields === null) {
+      throw new Error('objectRecord.fields must be a non-null object.');
+    }
+
+    // Set state.hydrating to suppress dirty tracking and allow platform field
+    // writes for the duration of hydration. Cleared in the finally block.
+    const proxyState = _getProxyState(instance);
+    if (proxyState) { proxyState.hydrating = true; }
+    try {
+      this.hydrate(instance, fields as Record<string, unknown>);
+
+      // Hydrate platform fields (id, object, created, updated, livemode)
+      const platformFields = ['id', 'object', 'created', 'updated', 'livemode'];
+      for (const key of platformFields) {
+        if (key in objectRecord) {
+          (instance as unknown as Record<string, unknown>)[key] = objectRecord[key];
+        }
+      }
+    } finally {
+      if (proxyState) { proxyState.hydrating = false; }
+    }
+  }
+
+  executeMethod(request: ${wrapperName}Request, config: unknown, context: unknown): unknown {
+    const instance = this.createInstance();
+
+    if (request.objectRecord) {
+      this.hydrateObjectRecord(instance, request.objectRecord);
+    }
+
+    // Assert: slated updates must be empty after hydration. If they're not,
+    // something has gone wrong \u2014 hydration should never produce slated updates.
+    const staleUpdates = _getSlatedUpdates(instance);
+    if (Object.keys(staleUpdates).length > 0) {
+      throw new Error('Invariant violation: slatedUpdates is non-empty after hydration. ' +
+        'Fields: ' + Object.keys(staleUpdates).join(', '));
+    }
+    const methodArgs = request.methodArgs ?? {};
+
+    switch (request.methodName) {
+${switchCases}
+    }
+    throw new Error(\`Unknown method: \${String(request.methodName)}\`);
+  }
+}
+
+export default new ${wrapperName}();`);
+  return parts.join("\n");
+}
+function buildWireConvertingSwitchCases(metadata, descriptorResult) {
+  const cases = [];
+  for (const action of Object.values(metadata.actions.instance)) {
+    const { apiName, methodName } = action;
+    const actionDescriptors = descriptorResult.descriptorNames.actions[apiName];
+    const inputDescriptor = actionDescriptors?.input;
+    const outputDescriptor = actionDescriptors?.output;
+    const caseLines = [];
+    caseLines.push(`      case "${apiName}": {`);
+    if (inputDescriptor) {
+      caseLines.push(
+        `        const nativeArgs = _apply(${inputDescriptor}, _ProtoWireToType, methodArgs);`
+      );
+      caseLines.push(`        const result = instance.${methodName}(nativeArgs);`);
+    } else {
+      caseLines.push(`        const result = instance.${methodName}(methodArgs);`);
+    }
+    if (outputDescriptor) {
+      caseLines.push(`        if (_isPromiseLike(result)) {`);
+      caseLines.push(
+        `          return Promise.resolve(result).then((r) => _buildMethodResponse(instance, _apply(${outputDescriptor}, _TypeToProtoWire, r)));`
+      );
+      caseLines.push(`        }`);
+      caseLines.push(
+        `        return _buildMethodResponse(instance, _apply(${outputDescriptor}, _TypeToProtoWire, result));`
+      );
+    } else {
+      caseLines.push(`        if (_isPromiseLike(result)) {`);
+      caseLines.push(
+        `          return Promise.resolve(result).then((r) => _buildMethodResponse(instance, r));`
+      );
+      caseLines.push(`        }`);
+      caseLines.push(`        return _buildMethodResponse(instance, result);`);
+    }
+    caseLines.push(`      }`);
+    cases.push(caseLines.join("\n"));
+  }
+  return cases.join("\n");
+}
+function generateLegacyWrapperClass(metadata, className) {
+  const wrapperName = `${className}Logic`;
+  const instanceCases = Object.keys(metadata.actions.instance).map(
+    (methodName) => `        case "${methodName}": return instance.${methodName}(args.args);`
+  ).join("\n");
+  const typeArgs = `
+type ExecuteMethodArg<K extends keyof InstanceMethodTypeMap> = {
+  type: "instance_method";
+  methodName: K;
+  args: InstanceMethodTypeMap[K]["argType"];
+};
+`.trim();
+  return `
+${typeArgs}
+
+class ${wrapperName} {
+  private instance: ${className};
+
+  constructor(instanceId?: string) {
+    this.instance = new ${className}(instanceId);
+  }
+
+  /**
+   * Hydrate the instance with data from the platform
+   */
+  hydrate(data: Record<string, unknown>): void {
+    Object.assign(this.instance, data);
+  }
+
+  executeMethod<K extends keyof InstanceMethodTypeMap>(args: ExecuteMethodArg<K>): InstanceMethodTypeMap[K]["returnType"] {
+    const instance = this.instance;
+    switch (args.methodName) {
+${instanceCases || "        default: throw new Error(`Unknown method: ${String(args.methodName)}`);"}
+    }
+    throw new Error(\`Unknown method: \${String(args.methodName)}\`);
+  }
+}
+`.trim();
+}
+
+// src/transformer/transform.ts
+function transform(sourceCode, fileName) {
+  const sourceContext = createInMemorySourceContext(sourceCode, fileName);
+  if ("errors" in sourceContext) {
+    return {
+      code: sourceCode,
+      metadata: [],
+      errors: sourceContext.errors
+    };
+  }
+  const discovery = discoverTransformPlanFromSourceFile(
+    sourceContext.sourceFile,
+    fileName
+  );
+  if (discovery.errors.length > 0) {
+    return {
+      code: sourceCode,
+      metadata: [],
+      errors: discovery.errors
+    };
+  }
+  return transformSourceFile(
+    sourceCode,
+    sourceContext.sourceFile,
+    discovery.plan,
+    fileName
+  );
+}
+function transformSourceFile(sourceCode, sourceFile, plan, fileName) {
+  const errors = [];
+  const metadata = [];
+  const transformedObjects = [];
+  try {
+    for (const plannedObject of plan.objects) {
+      const className = plannedObject.className;
+      try {
+        const classDecl = sourceFile.getClasses().find((candidate) => candidate.getName() === className);
+        if (!classDecl) {
+          throw new Error(`Could not find class "${className}" in source file.`);
+        }
+        const classMeta = plannedObject.platformMetadata;
+        injectPlatformMetadata(classDecl, classMeta);
+        injectConstructorProxy(classDecl);
+        for (const method of classDecl.getInstanceMethods()) {
+          if (classMeta.actions.instance[method.getName()]) {
+            injectAutoSave(method);
+          }
+        }
+        removeDecorators(classDecl);
+        const runtimeClassName = classDecl.getName();
+        if (runtimeClassName) {
+          const classIndex = classDecl.getChildIndex();
+          sourceFile.insertStatements(
+            classIndex + 1,
+            `_registerClass(${runtimeClassName});`
+          );
+        }
+        metadata.push(classMeta);
+        transformedObjects.push(plannedObject);
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        errors.push({
+          message: `Failed to transform class ${className}: ${errorMessage}`,
+          ...fileName !== void 0 && { file: fileName }
+        });
+      }
+    }
+    if (transformedObjects.length === 0) {
+      return {
+        code: sourceCode,
+        metadata: [],
+        errors
+      };
+    }
+    removeDecoratorImports(sourceFile);
+    const hasDescriptors = transformedObjects.some((obj) => obj.schemaData !== void 0);
+    injectRuntimeImports(sourceFile, hasDescriptors);
+    for (const plannedObject of transformedObjects) {
+      const wrapperClass = generateWrapperClass(
+        plannedObject.platformMetadata,
+        plannedObject.className,
+        plannedObject.schemaData
+      );
+      if (!plannedObject.schemaData) {
+        const instanceTypeMap = generateInstanceMethodTypeMap(
+          plannedObject.platformMetadata
+        );
+        sourceFile.addStatements([
+          "",
+          `// Generated type map for ${plannedObject.platformMetadata.apiName}`,
+          instanceTypeMap,
+          "",
+          `// Generated wrapper class for ${plannedObject.platformMetadata.apiName}`,
+          wrapperClass
+        ]);
+      } else {
+        sourceFile.addStatements([
+          "",
+          `// Generated wrapper class for ${plannedObject.platformMetadata.apiName}`,
+          wrapperClass
+        ]);
+      }
+    }
+    return {
+      code: sourceFile.getFullText(),
+      metadata,
+      errors
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    errors.push({
+      message: `Transform failed: ${errorMessage}`,
+      ...fileName !== void 0 && { file: fileName }
+    });
+    return {
+      code: sourceCode,
+      metadata: [],
+      errors
+    };
+  }
+}
+function discoverTransformPlanFromSourceFile(sourceFile, fileName) {
+  const errors = [];
+  try {
+    const objects = sourceFile.getClasses().filter(hasCustomObjectDecorator).map((classDecl) => ({
+      className: classDecl.getName() ?? "Anonymous",
+      platformMetadata: extractPlatformMetadata(classDecl)
+    }));
+    return {
+      plan: { objects },
+      errors
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    errors.push({
+      message: `Transform discovery failed: ${errorMessage}`,
+      ...fileName !== void 0 && { file: fileName }
+    });
+    return {
+      plan: { objects: [] },
+      errors
+    };
+  }
+}
+function createInMemorySourceContext(sourceCode, fileName) {
+  try {
+    const project = new Project({
+      useInMemoryFileSystem: true,
+      compilerOptions: {
+        target: 1,
+        module: 199,
+        moduleResolution: 3,
+        strict: true,
+        skipLibCheck: true
+      }
+    });
+    return {
+      sourceFile: project.createSourceFile(fileName ?? "source.ts", sourceCode)
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      errors: [
+        {
+          message: `Transform failed: ${errorMessage}`,
+          ...fileName !== void 0 && { file: fileName }
+        }
+      ]
+    };
+  }
+}
+
+// src/build/build.ts
+async function findTypeScriptFiles(dir, baseDir = dir) {
+  const files = [];
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name === "node_modules") {
+          continue;
+        }
+        const subFiles = await findTypeScriptFiles(fullPath, baseDir);
+        files.push(...subFiles);
+      } else if (entry.isFile()) {
+        if (entry.name.endsWith(".ts") && !entry.name.endsWith(".test.ts") && !entry.name.endsWith(".d.ts")) {
+          files.push(fullPath);
+        }
+      }
+    }
+  } catch {
+    return [];
+  }
+  return files;
+}
+async function ensureDir(dirPath) {
+  await mkdir(dirPath, { recursive: true });
+}
+async function build(options) {
+  const { inputDir, outputDir } = options;
+  const globalErrors = [];
+  const fileResults = [];
+  try {
+    const files = await findTypeScriptFiles(inputDir);
+    if (files.length === 0) {
+      return {
+        files: [],
+        errors: [
+          {
+            message: `No TypeScript files found in ${inputDir}`,
+            file: inputDir
+          }
+        ]
+      };
+    }
+    for (const inputPath of files) {
+      try {
+        const sourceCode = await readFile2(inputPath, "utf-8");
+        const result = transform(sourceCode, inputPath);
+        const relativePath = relative(inputDir, inputPath);
+        const outputPath = join(outputDir, relativePath);
+        await ensureDir(dirname(outputPath));
+        await writeFile(outputPath, result.code, "utf-8");
+        fileResults.push({
+          inputPath,
+          outputPath,
+          success: result.errors.length === 0,
+          errors: result.errors
+        });
+        if (result.errors.length > 0) {
+          globalErrors.push(...result.errors);
+        }
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const fileError = {
+          message: `Failed to process file: ${errorMessage}`,
+          file: inputPath
+        };
+        globalErrors.push(fileError);
+        fileResults.push({
+          inputPath,
+          outputPath: "",
+          success: false,
+          errors: [fileError]
+        });
+      }
+    }
+    return {
+      files: fileResults,
+      errors: globalErrors
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      files: fileResults,
+      errors: [
+        {
+          message: `Build failed: ${errorMessage}`
+        }
+      ]
+    };
+  }
+}
+
+// src/build/cli.ts
+import { _createCliContext } from "@stripe/extensibility-tool-utils";
+var logger = _createLogger({ name: "co-build" });
+function parseArgs() {
+  const args = process.argv.slice(2);
+  let inputDir;
+  let outputDir;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (!arg) continue;
+    if (arg === "--input" || arg === "-i") {
+      inputDir = args[i + 1];
+      i++;
+    } else if (arg === "--output" || arg === "-o") {
+      outputDir = args[i + 1];
+      i++;
+    } else if (arg === "--help" || arg === "-h") {
+      return null;
+    }
+  }
+  if (!inputDir || !outputDir) {
+    return null;
+  }
+  return { input: inputDir, output: outputDir };
+}
+function printUsage(ux) {
+  ux.print(`
+Usage: custom-objects-build --input <dir> --output <dir>
+
+Options:
+  --input, -i   Input directory containing TypeScript source files
+  --output, -o  Output directory for transformed files
+  --help, -h    Show this help message
+
+Example:
+  custom-objects-build --input src --output dist
+`);
+}
+async function main() {
+  const ctx = _createCliContext();
+  const parsed = parseArgs();
+  if (!parsed) {
+    printUsage(ctx.ux);
+    process.exit(1);
+  }
+  ctx.ux.log(`Building custom objects...`);
+  ctx.ux.log(`  Input:  ${parsed.input}`);
+  ctx.ux.log(`  Output: ${parsed.output}`);
+  const result = await build({
+    inputDir: parsed.input,
+    outputDir: parsed.output
+  });
+  ctx.ux.log(`
+Processed ${String(result.files.length)} file(s)`);
+  const successCount = result.files.filter((f) => f.success).length;
+  const failureCount = result.files.filter((f) => !f.success).length;
+  ctx.ux.log(`  Success: ${String(successCount)}`);
+  if (failureCount > 0) {
+    ctx.ux.log(`  Failed:  ${String(failureCount)}`);
+  }
+  if (result.errors.length > 0) {
+    ctx.ux.error(`
+${String(result.errors.length)} error(s) occurred:`);
+    for (const error of result.errors) {
+      if (error.file) {
+        ctx.ux.error(`  [${error.file}] ${error.message}`);
+      } else {
+        ctx.ux.error(`  ${error.message}`);
+      }
+    }
+    process.exit(1);
+  }
+  ctx.ux.log(`
+Build complete!`);
+}
+main().catch((error) => {
+  logger.error({ err: error }, "Build failed");
+  process.exit(1);
+});