@stripe/extensibility-custom-objects-tools 0.41.0 → 0.42.1

package/dist/build/extract-schemas.cli.cjs

@@ -8137,6 +8137,7 @@ function buildCustomObjectPackage(options, dependencies = {}) {
       appendTransformPlan(transformPlans, target.modulePath, analysis.transformPlan);
     }
     if (analysis.buildResult) {
+      diagnostics.push(...validateCustomObjectBuildResult(analysis.buildResult));
       objects[toObjectKey(target)] = analysis.buildResult;
     }
   }
@@ -8177,6 +8178,377 @@ function buildCustomObjectPackage(options, dependencies = {}) {
 function toObjectKey(target) {
   return `${target.modulePath}#${target.exportName}`;
 }
+function validateCustomObjectBuildResult(buildResult) {
+  const diagnostics = [];
+  const fieldsSchema = resolveTopLevelSchema(buildResult.fields.jsonSchema);
+  validateTopLevelObjectShape(fieldsSchema, buildResult, "fields_payload", diagnostics);
+  validatePropertyMap(fieldsSchema, buildResult, diagnostics, "field");
+  for (const [actionApiName, action] of Object.entries(buildResult.actions)) {
+    if (action.input?.jsonSchema) {
+      const inputSchema = resolveTopLevelSchema(action.input.jsonSchema);
+      validateTopLevelObjectShape(
+        inputSchema,
+        buildResult,
+        "action_input_payload",
+        diagnostics,
+        actionApiName
+      );
+      validatePropertyMap(
+        inputSchema,
+        buildResult,
+        diagnostics,
+        "action_input_field",
+        actionApiName
+      );
+    }
+    const outputSchema = resolveTopLevelSchema(action.output.jsonSchema);
+    validateTopLevelObjectShape(
+      outputSchema,
+      buildResult,
+      "action_output_payload",
+      diagnostics,
+      actionApiName
+    );
+    validatePropertyMap(
+      outputSchema,
+      buildResult,
+      diagnostics,
+      "action_output_field",
+      actionApiName
+    );
+  }
+  return diagnostics;
+}
+function validatePropertyMap(schema, buildResult, diagnostics, kind, actionApiName) {
+  if (!schema?.properties) {
+    return;
+  }
+  const defs = schema.$defs ?? {};
+  for (const [propertyName, propSchema] of Object.entries(schema.properties)) {
+    const resolved = resolveSchemaRef(propSchema, defs);
+    validatePropertySchema(
+      resolved,
+      buildResult,
+      diagnostics,
+      buildPropertyScope(kind, propertyName, actionApiName)
+    );
+  }
+}
+function buildPropertyScope(kind, propertyName, actionApiName) {
+  switch (kind) {
+    case "field":
+      return { kind, propertyName };
+    case "action_input_field":
+    case "action_output_field":
+      return {
+        kind,
+        actionApiName: actionApiName ?? "(unknown action)",
+        propertyName
+      };
+  }
+}
+function validateTopLevelObjectShape(schema, buildResult, kind, diagnostics, actionApiName) {
+  const hasProperties = schema.properties !== void 0 && Object.keys(schema.properties).length > 0;
+  const looksObjectLike = schema.type === "object" || hasProperties;
+  if (schema.additionalProperties !== void 0 && schema.additionalProperties !== false) {
+    diagnostics.push(
+      createUnsupportedSchemaDiagnostic(
+        kind,
+        buildResult,
+        buildPayloadScope(kind, actionApiName),
+        schema,
+        getTopLevelMapShapeDetail(kind)
+      )
+    );
+    return;
+  }
+  if (looksObjectLike) {
+    return;
+  }
+  diagnostics.push(
+    createUnsupportedSchemaDiagnostic(
+      kind,
+      buildResult,
+      buildPayloadScope(kind, actionApiName),
+      schema,
+      getTopLevelObjectShapeDetail(kind)
+    )
+  );
+}
+function buildPayloadScope(kind, actionApiName) {
+  switch (kind) {
+    case "fields_payload":
+      return { kind };
+    case "action_input_payload":
+    case "action_output_payload":
+      return { kind, actionApiName: actionApiName ?? "(unknown action)" };
+  }
+}
+function getTopLevelObjectShapeDetail(kind) {
+  switch (kind) {
+    case "fields_payload":
+      return "Custom object fields must be object-shaped.";
+    case "action_input_payload":
+    case "action_output_payload":
+      return "Action inputs and outputs must be object-shaped for custom objects.";
+  }
+}
+function getTopLevelMapShapeDetail(kind) {
+  switch (kind) {
+    case "fields_payload":
+      return "Custom object fields must declare named fields. Record<string, T> and other map-shaped field payloads are not supported for custom objects.";
+    case "action_input_payload":
+    case "action_output_payload":
+      return "Action inputs and outputs must declare named fields. Record<string, T> and other map-shaped payloads are not supported for custom objects.";
+  }
+}
+function validatePropertySchema(schema, buildResult, diagnostics, scope) {
+  if (hasNonStringEnumValues(schema)) {
+    diagnostics.push(
+      createUnsupportedSchemaDiagnostic(
+        scope.kind,
+        buildResult,
+        scope,
+        schema,
+        "Only string enums are supported for custom objects."
+      )
+    );
+    return;
+  }
+  if (schema.format === "decimal") {
+    diagnostics.push(
+      createUnsupportedSchemaDiagnostic(
+        scope.kind,
+        buildResult,
+        scope,
+        schema,
+        "Decimal fields are not supported for custom objects."
+      )
+    );
+    return;
+  }
+  if (schema.type === "number") {
+    diagnostics.push(
+      createUnsupportedSchemaDiagnostic(
+        scope.kind,
+        buildResult,
+        scope,
+        schema,
+        "Number fields are not supported for custom objects. Use Integer for whole numbers."
+      )
+    );
+    return;
+  }
+  if (schema.type === "array") {
+    diagnostics.push(
+      createUnsupportedSchemaDiagnostic(
+        scope.kind,
+        buildResult,
+        scope,
+        schema,
+        "Array fields are not supported for custom objects."
+      )
+    );
+    return;
+  }
+  const refTarget = schema.type === "object" ? getRefTargetType(schema) : null;
+  if (schema.type === "object" && refTarget === null) {
+    diagnostics.push(
+      createUnsupportedSchemaDiagnostic(
+        scope.kind,
+        buildResult,
+        scope,
+        schema,
+        "Nested object fields are not supported for custom objects. Use Ref<T> for object references."
+      )
+    );
+    return;
+  }
+  validateNumericBoundary(schema, buildResult, diagnostics, scope);
+  validateDefaultValue(schema, buildResult, diagnostics, scope);
+  if (!isSupportedCustomObjectSchema(schema, refTarget)) {
+    diagnostics.push(
+      createUnsupportedSchemaDiagnostic(
+        scope.kind,
+        buildResult,
+        scope,
+        schema,
+        "This schema shape is not supported for custom objects."
+      )
+    );
+  }
+}
+function validateNumericBoundary(schema, buildResult, diagnostics, scope) {
+  const boundaries = [
+    ["minimum", schema.minimum],
+    ["exclusiveMinimum", schema.exclusiveMinimum],
+    ["maximum", schema.maximum],
+    ["exclusiveMaximum", schema.exclusiveMaximum]
+  ];
+  for (const [name, value] of boundaries) {
+    if (value === void 0 || Number.isInteger(value)) {
+      continue;
+    }
+    diagnostics.push(
+      createUnsupportedSchemaDiagnostic(
+        scope.kind,
+        buildResult,
+        scope,
+        schema,
+        `${name}=${String(value)} is not representable for custom objects; only integer numeric boundaries are supported.`
+      )
+    );
+  }
+}
+function validateDefaultValue(schema, buildResult, diagnostics, scope) {
+  if (schema.type === "integer" && schema.default !== void 0 && (typeof schema.default !== "number" || !Number.isInteger(schema.default))) {
+    diagnostics.push(
+      createUnsupportedSchemaDiagnostic(
+        scope.kind,
+        buildResult,
+        scope,
+        schema,
+        `default=${JSON.stringify(schema.default)} is not representable for custom objects; integer fields require integer default values.`
+      )
+    );
+  }
+}
+function isSupportedCustomObjectSchema(schema, refTarget) {
+  if (extractEnumValues(schema) !== null) {
+    return true;
+  }
+  if (refTarget !== null) {
+    return true;
+  }
+  switch (schema.type) {
+    case "string":
+    case "integer":
+    case "boolean":
+      return true;
+    default:
+      return false;
+  }
+}
+function createUnsupportedSchemaDiagnostic(kind, buildResult, scope, schema, detail) {
+  const { modulePath, className } = buildResult.platformMetadata;
+  return {
+    severity: "error",
+    code: getUnsupportedSchemaDiagnosticCode(kind),
+    message: `${describeValidationScope(scope)} on "${className}" in "${modulePath}" is not supported for custom objects (${describeSchema(schema)}). ${detail}`,
+    modulePath,
+    exportName: className
+  };
+}
+function getUnsupportedSchemaDiagnosticCode(kind) {
+  switch (kind) {
+    case "fields_payload":
+    case "field":
+      return "UNSUPPORTED_FIELD_SCHEMA";
+    case "action_input_field":
+    case "action_input_payload":
+      return "UNSUPPORTED_ACTION_INPUT_SCHEMA";
+    case "action_output_field":
+    case "action_output_payload":
+      return "UNSUPPORTED_ACTION_OUTPUT_SCHEMA";
+  }
+}
+function describeValidationScope(scope) {
+  switch (scope.kind) {
+    case "fields_payload":
+      return "Custom object fields schema";
+    case "field":
+      return `Field "${scope.propertyName}"`;
+    case "action_input_field":
+      return `Action "${scope.actionApiName}" input field "${scope.propertyName}"`;
+    case "action_output_field":
+      return `Action "${scope.actionApiName}" output field "${scope.propertyName}"`;
+    case "action_input_payload":
+      return `Action "${scope.actionApiName}" input payload`;
+    case "action_output_payload":
+      return `Action "${scope.actionApiName}" output payload`;
+  }
+}
+function describeSchema(schema) {
+  if (Array.isArray(schema.type)) {
+    return `type: [${schema.type.join(", ")}]`;
+  }
+  if (schema.type === "string" && typeof schema.format === "string") {
+    return `type: string, format: ${schema.format}`;
+  }
+  if (schema.type === "object") {
+    return "type: object";
+  }
+  if (schema.type !== void 0) {
+    return `type: ${schema.type}`;
+  }
+  if (Array.isArray(schema.anyOf) && schema.anyOf.length > 0) {
+    return "anyOf union";
+  }
+  if (Array.isArray(schema.oneOf) && schema.oneOf.length > 0) {
+    return "oneOf union";
+  }
+  return "untyped schema";
+}
+function resolveSchemaRef(schema, defs) {
+  const ref = schema.$ref;
+  if (!ref) return schema;
+  if (!ref.startsWith("#/$defs/")) return schema;
+  const defName = ref.slice("#/$defs/".length);
+  const defSchema = defs[defName];
+  if (!defSchema) return schema;
+  const { $ref: _, ...rest } = schema;
+  return { ...defSchema, ...rest };
+}
+function resolveTopLevelSchema(schema) {
+  return resolveSchemaRef(schema, schema.$defs ?? {});
+}
+function getRefTargetType(schema) {
+  if (!schema.properties) return null;
+  const properties = schema.properties;
+  const realProps = Object.keys(properties).filter((key) => !key.startsWith("__"));
+  const allowedProps = /* @__PURE__ */ new Set(["id", "type", "url"]);
+  if (realProps.length === 0 || realProps.some((key) => !allowedProps.has(key))) {
+    return null;
+  }
+  const idProp = properties.id;
+  const typeProp = properties.type;
+  if (!idProp || !typeProp) return null;
+  if (idProp.type !== "string") return null;
+  const requiredSet = new Set(schema.required ?? []);
+  if (!requiredSet.has("id") || !requiredSet.has("type")) return null;
+  return extractSingleLiteral(typeProp);
+}
+function extractSingleLiteral(schema) {
+  if (Array.isArray(schema.enum) && schema.enum.length === 1 && typeof schema.enum[0] === "string") {
+    return schema.enum[0];
+  }
+  if (Array.isArray(schema.oneOf) && schema.oneOf.length === 1 && schema.oneOf.every(
+    (item) => "const" in item && typeof item.const === "string"
+  )) {
+    const values = schema.oneOf.map(
+      (item) => String(item.const)
+    );
+    return values[0] ?? null;
+  }
+  return null;
+}
+function extractEnumValues(schema) {
+  if (Array.isArray(schema.enum) && schema.enum.every((value) => typeof value === "string")) {
+    return schema.enum.map(String);
+  }
+  if (Array.isArray(schema.oneOf) && schema.oneOf.length > 0 && schema.oneOf.every(
+    (item) => "const" in item && typeof item.const === "string"
+  )) {
+    return schema.oneOf.map((item) => String(item.const));
+  }
+  return null;
+}
+function hasNonStringEnumValues(schema) {
+  if (Array.isArray(schema.enum) && schema.enum.length > 0) {
+    return schema.enum.some((value) => typeof value !== "string");
+  }
+  return Array.isArray(schema.oneOf) && schema.oneOf.length > 0 && schema.oneOf.every((item) => "const" in item) && schema.oneOf.some((item) => typeof item.const !== "string");
+}
 var PRIMARY_FIELD_TAG_RE = /@primaryField\s*(?:$|\*)/m;
 var SECONDARY_FIELD_TAG_RE = /@secondaryField\s*(?:$|\*)/m;
 var API_NAME_TAG_RE = /@apiName\s+(\S+)/;
@@ -8729,6 +9101,14 @@ async function main() {
         );
       }
       const result = buildCustomObjectPackage({ targets: parsed });
+      const errorDiagnostics = result.diagnostics.filter(
+        (diagnostic) => diagnostic.severity === "error"
+      );
+      if (errorDiagnostics.length > 0) {
+        throw new Error(
+          errorDiagnostics.map((diagnostic) => diagnostic.message).join("\n")
+        );
+      }
       const output = {
         schemas: result.objects,
         diagnostics: result.diagnostics