@seamapi/nextlove-sdk-generator 1.4.0

package/src/lib/generate-php-sdk/utils/deep-flatten-one-of-and-all-of-schema.ts

@@ -0,0 +1,128 @@
+import type {
+  AllOfSchema,
+  ArraySchema,
+  ObjSchema,
+  OneOfSchema,
+  PrimitiveSchema,
+  PropertySchema,
+} from "lib/types.js"
+
+export function deepFlattenOneOfAndAllOfSchema(schema: PropertySchema) {
+  if ("oneOf" in schema) {
+    return flattenOneOf(schema)
+  } else if ("allOf" in schema) {
+    return flattenAllOf(schema)
+  } else if (
+    "type" in schema &&
+    schema.type === "object" &&
+    schema.properties
+  ) {
+    return flattenObject(schema)
+  } else if ("type" in schema && schema.type === "array" && schema.items) {
+    return flattenArray(schema)
+  } else {
+    // For primitive types, return the schema as is
+    return schema
+  }
+}
+
+function flattenOneOf(one_of_schema: OneOfSchema): ObjSchema | PrimitiveSchema {
+  const flattened_schema = {
+    type: "object",
+    properties: {},
+    required: [],
+  } as ObjSchema
+
+  for (const sub_schema of one_of_schema.oneOf) {
+    const flattened_sub_schema = deepFlattenOneOfAndAllOfSchema(sub_schema)
+
+    // Check if the sub-schema is a primitive schema
+    if (
+      "type" in flattened_sub_schema &&
+      !("properties" in flattened_sub_schema)
+    ) {
+      return { type: flattened_sub_schema.type } as PrimitiveSchema
+    }
+
+    if ("$ref" in flattened_sub_schema) {
+      console.error("$ref not currently supported when flattening oneOf")
+      continue
+    }
+
+    // Merge properties
+    Object.assign(flattened_schema.properties, flattened_sub_schema.properties)
+
+    // Update required array with common properties
+    flattened_schema.required =
+      flattened_schema.required.length === 0
+        ? flattened_sub_schema.required
+        : flattened_schema.required.filter((prop) =>
+            flattened_sub_schema.required.includes(prop)
+          )
+  }
+
+  return flattened_schema
+}
+
+function flattenAllOf(all_of_schema: AllOfSchema): ObjSchema | PrimitiveSchema {
+  const flattened_schema = {
+    type: "object",
+    properties: {},
+    required: [],
+  } as ObjSchema
+
+  for (const sub_Schema of all_of_schema.allOf) {
+    const flattened_sub_schema = deepFlattenOneOfAndAllOfSchema(sub_Schema)
+
+    // Check if the sub-schema is a primitive schema
+    if (
+      "type" in flattened_sub_schema &&
+      !("properties" in flattened_sub_schema)
+    ) {
+      return { type: flattened_sub_schema.type } as PrimitiveSchema
+    }
+
+    if ("$ref" in flattened_sub_schema) {
+      console.error("$ref not currently supported when flattening allOf")
+      continue
+    }
+
+    // Merge properties
+    Object.assign(flattened_schema.properties, flattened_sub_schema.properties)
+
+    // Merge required array
+    flattened_schema.required = [
+      ...new Set([
+        ...flattened_schema.required,
+        ...flattened_sub_schema.required,
+      ]),
+    ]
+  }
+
+  return flattened_schema
+}
+
+function flattenObject(obj_schema: ObjSchema) {
+  const flattened_schema = {
+    type: "object",
+    properties: {},
+    required: obj_schema.required || [],
+  } as ObjSchema
+
+  for (const prop in obj_schema.properties) {
+    flattened_schema.properties[prop] = deepFlattenOneOfAndAllOfSchema(
+      obj_schema.properties[prop]!
+    )
+  }
+
+  return flattened_schema
+}
+
+function flattenArray(array_schema: ArraySchema): ArraySchema {
+  const flattened_schema = {
+    type: "array",
+    items: deepFlattenOneOfAndAllOfSchema(array_schema.items),
+  } as ArraySchema
+
+  return flattened_schema
+}

package/src/lib/generate-php-sdk/utils/generate-resource-object-class.ts

@@ -0,0 +1,105 @@
+import type { PropertySchemaWithReferenceObject } from "./deep-extract-resource-object-schemas.js"
+import { getPhpType } from "./get-php-type.js"
+
+interface Params {
+  resource_name: string
+  resource_properties: Record<string, PropertySchemaWithReferenceObject>
+  required_property_names: string[]
+}
+
+export const generateResourceObjectClass = ({
+  resource_name,
+  resource_properties,
+  required_property_names,
+}: Params) => {
+  const generateTypeDefinition = (
+    prop_name: string,
+    prop_schema: PropertySchemaWithReferenceObject
+  ) => {
+    const is_object_referencing_resource =
+      "type" in prop_schema &&
+      prop_schema.type === "object" &&
+      "reference_object_type_name" in prop_schema
+
+    const is_array_referencing_resource =
+      "type" in prop_schema &&
+      prop_schema.type === "array" &&
+      "reference_object_type_name" in prop_schema
+
+    if (is_object_referencing_resource) {
+      return `${prop_name}: ${
+        prop_schema.reference_object_type_name
+      }::from_json($json->${prop_name})${
+        required_property_names.includes(prop_name) ? "," : " ?? null,"
+      }`
+    } else if (is_array_referencing_resource) {
+      return `${prop_name}: array_map(
+          fn ($${prop_name[0]}) => ${prop_schema.reference_object_type_name}::from_json($${prop_name[0]}),
+          $json->${prop_name} ?? []
+        ),`
+    } else {
+      return `${prop_name}: $json->${prop_name}${
+        required_property_names.includes(prop_name) ? "," : " ?? null,"
+      }`
+    }
+  }
+
+  const generateFromJsonMethod = () => {
+    return `
+    public static function from_json(mixed $json): ${resource_name}|null
+    {
+        if (!$json) {
+            return null;
+        }
+        return new self(
+            ${Object.entries(resource_properties)
+              .map(([prop, prop_schema]) =>
+                generateTypeDefinition(prop, prop_schema)
+              )
+              .join("\n            ")}
+        );
+    }
+  `
+  }
+
+  const generateConstructor = () => {
+    return `
+    public function __construct(
+        ${Object.entries(resource_properties)
+          .map(([prop_name, prop_schema]) => {
+            const is_object_referencing_resource =
+              "type" in prop_schema &&
+              prop_schema.type === "object" &&
+              "reference_object_type_name" in prop_schema
+            const php_type = is_object_referencing_resource
+              ? prop_schema.reference_object_type_name
+              : getPhpType("type" in prop_schema ? prop_schema.type : "mixed")
+
+            return `public ${php_type}${
+              php_type === "mixed"
+                ? ""
+                : required_property_names.includes(prop_name)
+                ? ""
+                : " | null"
+            } $${prop_name},`
+          })
+          .join("\n        ")}
+    ) {
+    }
+  `
+  }
+
+  const phpClass = `<?php
+
+namespace Seam\\Objects;
+
+class ${resource_name}
+{
+    ${generateFromJsonMethod()}
+
+    ${generateConstructor()}
+}
+`
+
+  return phpClass
+}

package/src/lib/generate-php-sdk/utils/generate-seam-client.ts

@@ -0,0 +1,115 @@
+import type { PhpClient } from "./php-client.js"
+
+interface Params {
+  resource_clients: PhpClient[]
+  resource_object_names: string[]
+}
+
+export const generateSeamClient = ({
+  resource_clients,
+  resource_object_names,
+}: Params) => {
+  const parent_resource_clients = resource_clients.filter(
+    (c) => c.is_parent_client
+  )
+
+  return `<?php
+
+namespace Seam;
+
+${resource_object_names.map((n) => `use Seam\\Objects\\${n};`).join("\n")}
+
+use GuzzleHttp\\Client as HTTPClient;
+use \\Exception as Exception;
+
+class SeamClient
+{
+  ${parent_resource_clients
+    .map((c) => `public ${c.client_name}Client $${c.namespace};`)
+    .join("\n  ")}
+
+  public string $api_key;
+  public HTTPClient $client;
+
+  public function __construct(
+    $api_key,
+    $endpoint = "https://connect.getseam.com",
+    $throw_http_errors = false
+  ) {
+    $this->api_key = $api_key;
+    $this->client = new HTTPClient([
+      "base_uri" => $endpoint,
+      "timeout" => 60.0,
+      "headers" => [
+        "Authorization" => "Bearer " . $this->api_key,
+        "User-Agent" => "Seam PHP Client 0.0.1",
+      ],
+      "http_errors" => $throw_http_errors,
+    ]);
+    ${parent_resource_clients
+      .map((c) => `$this->${c.namespace} = new ${c.client_name}Client($this);`)
+      .join("\n    ")}
+  }
+
+  public function request(
+    $method,
+    $path,
+    $json = null,
+    $query = null,
+    $inner_object = null
+  ) {
+    $options = [
+      "json" => $json,
+      "query" => $query,
+    ];
+    $options = array_filter($options, fn ($option) => $option !== null);
+
+    // TODO handle request errors
+    $response = $this->client->request($method, $path, $options);
+    $statusCode = $response->getStatusCode();
+
+    $res_json = null;
+    try {
+      $res_json = json_decode($response->getBody());
+    } catch (Exception $ignoreError) {
+    }
+
+    if (($res_json->error ?? null) != null) {
+      throw new Exception(
+        "Error Calling \\"" .
+          $method .
+          " " .
+          $path .
+          "\\" : " .
+          ($res_json->error->type ?? "") .
+          ": " .
+          $res_json->error->message
+      );
+    }
+
+    if ($statusCode >= 400) {
+      throw new Exception(
+        "HTTP Error: [" . $statusCode . "] " . $method . " " . $path
+      );
+    }
+
+    if ($inner_object) {
+      if (!is_array($res_json->$inner_object) && ($res_json->$inner_object ?? null) == null) {
+        throw new Exception(
+          'Missing Inner Object "' .
+            $inner_object .
+            '" for ' .
+            $method .
+            " " .
+            $path
+        );
+      }
+      return $res_json->$inner_object;
+    }
+    return $res_json;
+  }
+}
+
+${resource_clients.map((c) => c.serialize()).join("\n\n")}
+`
+}

package/src/lib/generate-php-sdk/utils/get-php-type.ts

@@ -0,0 +1,21 @@
+export const getPhpType = (zod_type: string) => {
+  switch (zod_type) {
+    case "string":
+      return "string"
+
+    case "number":
+      return "float"
+
+    case "boolean":
+      return "bool"
+
+    case "object":
+      return "mixed"
+
+    case "array":
+      return "array"
+
+    default:
+      return "mixed"
+  }
+}

package/src/lib/generate-php-sdk/utils/php-client.ts

@@ -0,0 +1,189 @@
+export type PhpClientMethodParameter = {
+  name: string
+  type: string
+  required?: boolean | undefined
+  position?: number | undefined
+}
+
+export type PhpClientMethod = {
+  method_name: string
+  path: string
+  parameters: PhpClientMethodParameter[]
+  return_resource: string
+  return_path: string
+  is_array_response: boolean
+}
+
+type ClientName = string
+type Namespace = string
+export type PhpClientIdentifiers = {
+  client_name: ClientName
+  namespace: Namespace
+}
+
+export class PhpClient {
+  methods: PhpClientMethod[] = []
+
+  constructor(
+    public client_name: ClientName,
+    public namespace: Namespace,
+    public is_parent_client: boolean,
+    public child_client_identifiers: PhpClientIdentifiers[]
+  ) {
+    this.methods = []
+  }
+
+  addMethod(method: PhpClientMethod) {
+    this.methods.push(method)
+  }
+
+  serialize() {
+    const has_child_clients = this.child_client_identifiers.length > 0
+
+    return [
+      `class ${this.client_name}Client`,
+      `{`,
+      `  private SeamClient $seam;`,
+      `  ${
+        has_child_clients
+          ? this.child_client_identifiers
+              .map((i) => `  public ${i.client_name}Client $${i.namespace};`)
+              .join("\n")
+          : ""
+      }`,
+      `  public function __construct(SeamClient $seam)`,
+      `  {`,
+      `    $this->seam = $seam;`,
+      `    ${
+        has_child_clients
+          ? this.child_client_identifiers
+              .map(
+                (i) =>
+                  `$this->${i.namespace} = new ${i.client_name}Client($seam);`
+              )
+              .join("\n")
+          : ""
+      }`,
+      `  }`,
+      "",
+      ...this.methods.map(
+        ({
+          method_name,
+          path,
+          parameters,
+          return_resource,
+          return_path,
+          is_array_response,
+        }) => {
+          const does_method_use_action_attempt =
+            return_resource === "ActionAttempt" &&
+            this.client_name !== "ActionAttempts"
+          const method_return_type = is_array_response
+            ? "array"
+            : return_resource
+            ? return_resource
+            : "void"
+
+          return [
+            "",
+            `  public function ${method_name}(`,
+            `    ${parameters
+              .sort(
+                (a, b) =>
+                  (a.position ?? a.required ? 1000 : 9999) -
+                  (b.position ?? b.required ? 1000 : 9999)
+              )
+              .map((p) => `${p.type} $${p.name}${p.required ? "" : " = null"}`)
+              .concat(
+                does_method_use_action_attempt
+                  ? ["bool $wait_for_action_attempt = true"]
+                  : []
+              )
+              .join(",\n    ")}`,
+            `  ): ${method_return_type} {`,
+
+            `    $request_payload = [];`,
+            ``,
+
+            `${parameters
+              .map((p) =>
+                [
+                  `    if ($${p.name} !== null) {`,
+                  `      $request_payload["${p.name}"] = $${p.name};`,
+                  `    }`,
+                ].join("\n")
+              )
+              .join("\n")}`,
+            ``,
+
+            `    ${return_resource ? "$res = " : ""}$this->seam->request(`,
+            `      "POST",`,
+            `      "${path}",`,
+            `      json: $request_payload,`,
+            `      ${return_path ? `inner_object: "${return_path}",` : ""}`,
+            `    );`,
+            ``,
+
+            does_method_use_action_attempt
+              ? [
+                  "    if (!$wait_for_action_attempt) {",
+                  `      return ${return_resource}::from_json($res);`,
+                  "    }",
+                ].join("\n")
+              : "",
+            ``,
+            does_method_use_action_attempt
+              ? [
+                  `    $action_attempt = $this->seam->action_attempts->poll_until_ready(`,
+                  `      $res->action_attempt_id`,
+                  `    );`,
+                  ``,
+                  `    return $action_attempt;`,
+                ].join("\n")
+              : "",
+            ``,
+
+            return_resource && !does_method_use_action_attempt
+              ? `    return ${
+                  is_array_response
+                    ? `array_map(fn ($r) => ${return_resource}::from_json($r), $res);`
+                    : `${return_resource}::from_json($res);`
+                }`
+              : "",
+            `  }`,
+          ].join("\n")
+        }
+      ),
+      this.client_name === "ActionAttempts"
+        ? [
+            "  public function poll_until_ready(string $action_attempt_id): ActionAttempt",
+            "  {",
+            "    $seam = $this->seam;",
+            "    $time_waiting = 0.0;",
+            "    $action_attempt = $seam->action_attempts->get($action_attempt_id);",
+            "",
+            '    while ($action_attempt->status == "pending") {',
+            "      $action_attempt = $seam->action_attempts->get(",
+            "        $action_attempt->action_attempt_id",
+            "      );",
+            "      if ($time_waiting > 20.0) {",
+            '        throw new Exception("Timed out waiting for access code to be created");',
+            "      }",
+            "      $time_waiting += 0.4;",
+            "      usleep(400000); // sleep for 0.4 seconds",
+            "    }",
+            "",
+            '    if ($action_attempt->status == "failed") {',
+            "      throw new Exception(",
+            '        "Action Attempt failed: " . $action_attempt->error->message',
+            "      );",
+            "    }",
+            "",
+            "    return $action_attempt;",
+            "  }",
+          ].join("\n")
+        : "",
+      "}",
+    ].join("\n")
+  }
+}

package/src/lib/generate-python-sdk/class-file.ts

@@ -0,0 +1,114 @@
+export type ClassFileMethod = {
+  method_name: string
+  path: string
+  parameters: Array<{
+    name: string
+    type: string
+    position?: number | undefined
+  }>
+  return_path: string[]
+  return_resource: string
+}
+
+export class ClassFile {
+  name: string
+  namespace: string | undefined
+  methods: ClassFileMethod[]
+
+  constructor(name: string, namespace?: string | undefined) {
+    this.name = name
+    this.namespace = namespace
+    this.methods = []
+  }
+
+  addMethod(method: ClassFileMethod) {
+    this.methods.push(method)
+  }
+
+  serializeToAbstractClassWithoutImports(): string {
+    return [
+      `class Abstract${this.name}(abc.ABC):`,
+      this.methods.length === 0 ? `  pass` : "",
+      ...this.methods.map(({ method_name, parameters }) =>
+        [
+          "",
+          "",
+          `@abc.abstractmethod`,
+          `def ${method_name}(self, ${parameters
+            .sort((a, b) => (a.position ?? 9999) - (b.position ?? 9999))
+            .map(({ name, type, position }) =>
+              position !== undefined
+                ? `${name}: ${type}`
+                : `${name}: Optional[${type}] = None`
+            )
+            .join(", ")}):`,
+          `  raise NotImplementedError()`,
+        ]
+          .map((s) => `  ${s}`)
+          .join("\n")
+      ),
+    ].join("\n")
+  }
+
+  serializeToClass(): string {
+    return [
+      `from seamapi.types import (${[
+        `Abstract${this.name}`,
+        `AbstractSeam as Seam`,
+        ...Array.from(
+          new Set(
+            this.methods.map((m) =>
+              m.return_resource.replace(/^List\[/, "").replace(/\]$/, "")
+            )
+          )
+        ),
+      ].join(",")})`,
+      `from typing import (Optional, Any)`,
+      "",
+      `class ${this.name}(Abstract${this.name}):`,
+      // TODO DOCSTRING
+      `  seam: Seam`,
+      "",
+      `  def __init__(self, seam: Seam):`,
+      `    self.seam = seam`,
+      "",
+      ...this.methods.map(
+        ({ method_name, path, return_resource, return_path, parameters }) => {
+          const is_return_resource_a_list = return_resource.startsWith("List[")
+          const list_item_type = return_resource.slice(5, -1)
+          return [
+            "",
+            "",
+            `def ${method_name}(self, ${parameters
+              .sort((a, b) => (a.position ?? 9999) - (b.position ?? 9999))
+              .map(({ name, type, position }) =>
+                position !== undefined
+                  ? `${name}: ${type}`
+                  : `${name}: Optional[${type}] = None`
+              )
+              .join(", ")}):`,
+            `  json_payload = {}`,
+            ...parameters.map(
+              ({ name }) =>
+                `  if ${name} is not None:\n      json_payload["${name}"] = ${name}`
+            ),
+            `  res = self.seam.make_request(`,
+            `    "POST",`,
+            `    "${path}",`,
+            `    json=json_payload`,
+            `  )`,
+            is_return_resource_a_list
+              ? `  return [${list_item_type}.from_dict(item) for item in res["${return_path.join(
+                  '"]["'
+                )}"]]`
+              : `  return ${return_resource}.from_dict(res["${return_path.join(
+                  '"]["'
+                )}"])`,
+          ]
+            .map((s) => `  ${s}`)
+            .join("\n")
+        }
+      ),
+    ].join("\n")
+  }
+}