@seamapi/nextlove-sdk-generator 1.4.0

package/src/lib/generate-csharp-sdk/templates/fs/src/Seam/Model/AsbtractModelSchema.cs

@@ -0,0 +1,62 @@
+using System;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Serialization;
+
+namespace Seam.Model
+{
+    /// <summary>
+    ///  Abstract base class for oneOf, anyOf schemas in the OpenAPI specification
+    /// </summary>
+    public abstract class AbstractModelSchema
+    {
+        /// <summary>
+        ///  Custom JSON serializer
+        /// </summary>
+        static public readonly JsonSerializerSettings SerializerSettings =
+            new JsonSerializerSettings
+            {
+                // OpenAPI generated types generally hide default constructors.
+                ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor,
+                MissingMemberHandling = MissingMemberHandling.Error,
+                ContractResolver = new DefaultContractResolver
+                {
+                    NamingStrategy = new CamelCaseNamingStrategy { OverrideSpecifiedNames = false }
+                }
+            };
+
+        /// <summary>
+        ///  Custom JSON serializer for objects with additional properties
+        /// </summary>
+        static public readonly JsonSerializerSettings AdditionalPropertiesSerializerSettings =
+            new JsonSerializerSettings
+            {
+                // OpenAPI generated types generally hide default constructors.
+                ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor,
+                MissingMemberHandling = MissingMemberHandling.Ignore,
+                ContractResolver = new DefaultContractResolver
+                {
+                    NamingStrategy = new CamelCaseNamingStrategy { OverrideSpecifiedNames = false }
+                }
+            };
+
+        /// <summary>
+        /// Gets or Sets the actual instance
+        /// </summary>
+        public abstract Object ActualInstance { get; set; }
+
+        /// <summary>
+        /// Gets or Sets IsNullable to indicate whether the instance is nullable
+        /// </summary>
+        public bool IsNullable { get; protected set; }
+
+        /// <summary>
+        /// Gets or Sets the schema type, which can be either `oneOf` or `anyOf`
+        /// </summary>
+        public string SchemaType { get; protected set; }
+
+        /// <summary>
+        /// Converts the instance into JSON string.
+        /// </summary>
+        public abstract string ToJson();
+    }
+}

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

@@ -0,0 +1,176 @@
+import axios from "axios"
+import type { OpenAPISchema, Route } from "lib/types.js"
+import { getParameterAndResponseSchema } from "lib/index.js"
+import { generateResourceObjectClass } from "./utils/generate-resource-object-class.js"
+import { pascalCase } from "change-case"
+import { getPhpType } from "./utils/get-php-type.js"
+import { PhpClient, type PhpClientIdentifiers } from "./utils/php-client.js"
+import { generateSeamClient } from "./utils/generate-seam-client.js"
+import { deepExtractResourceObjectSchemas } from "./utils/deep-extract-resource-object-schemas.js"
+import readmeMdTemplate from "./templates/readme.md.template.js"
+import packageJsonTemplate from "./templates/package.json.template.js"
+import composerJsonTemplate from "./templates/composer.json.template.js"
+import gitignoreTemplate from "./templates/gitignore.template.js"
+import envExampleTemplate from "./templates/env.example.template.js"
+import testFixtureTemplate from "./templates/test-fixture.template.js"
+import smokeTestTemplate from "./templates/smoke-test.template.js"
+
+export const generatePhpSDK = async () => {
+  const openapi: OpenAPISchema = await axios
+    .get("https://connect.getseam.com/openapi.json")
+    .then((res) => res.data)
+  const routes: Route[] = Object.entries(openapi.paths).map(([path, v]) => ({
+    path,
+    ...v,
+  }))
+
+  const fs: any = {}
+
+  fs["README.md"] = readmeMdTemplate()
+  fs["package.json"] = packageJsonTemplate()
+  fs["composer.json"] = composerJsonTemplate()
+  fs[".gitignore"] = gitignoreTemplate()
+  fs[".env.example"] = envExampleTemplate()
+  fs["tests/Fixture.php"] = testFixtureTemplate()
+  fs["tests/SmokeTest.php"] = smokeTestTemplate()
+
+  const base_resource_object_names: string[] = []
+  for (const [schema_name, schema] of Object.entries(
+    openapi.components.schemas
+  )) {
+    base_resource_object_names.push(pascalCase(schema_name))
+
+    const base_resource_schema_with_sub_schemas =
+      deepExtractResourceObjectSchemas({
+        schema_name,
+        schema_body: schema,
+      })
+
+    for (const { name, properties, required_property_names } of Object.values(
+      base_resource_schema_with_sub_schemas
+    )) {
+      fs[`src/Objects/${name}.php`] = generateResourceObjectClass({
+        resource_name: name,
+        resource_properties: properties,
+        required_property_names,
+      })
+    }
+  }
+
+  const parent_resource_to_children_map = routes.reduce(
+    (acc: Record<string, string[]>, route) => {
+      if (!route.post?.["x-fern-sdk-group-name"]) return acc
+
+      const [parent_resource_name, child_resource_name] =
+        route.post["x-fern-sdk-group-name"]
+
+      // Making TS happy
+      if (!parent_resource_name) return acc
+
+      if (!acc[parent_resource_name]) {
+        acc[parent_resource_name] = []
+      }
+
+      if (
+        child_resource_name &&
+        !acc[parent_resource_name]!.includes(child_resource_name)
+      ) {
+        acc[parent_resource_name]!.push(child_resource_name)
+      }
+
+      return acc
+    },
+    {}
+  )
+
+  const clients: Record<string, PhpClient> = {}
+
+  const processClient = (resource_name: string) => {
+    const child_client_identifiers: PhpClientIdentifiers[] = (
+      parent_resource_to_children_map[resource_name] ?? []
+    ).map((child_resource) => ({
+      client_name: pascalCase(`${resource_name} ${child_resource}`),
+      namespace: child_resource,
+    }))
+    const is_parent_client = Object.keys(
+      parent_resource_to_children_map
+    ).includes(resource_name)
+    const pascal_resource_name = pascalCase(resource_name)
+
+    clients[pascal_resource_name] = new PhpClient(
+      pascal_resource_name,
+      resource_name,
+      is_parent_client,
+      child_client_identifiers
+    )
+  }
+
+  for (const route of routes) {
+    if (!route.post || !route.post["x-fern-sdk-group-name"]) continue
+
+    const group_names = [...route.post["x-fern-sdk-group-name"]]
+    const [base_resource] = group_names
+    const namespace = group_names.join("_")
+    const client_name = pascalCase(namespace)
+
+    if (!clients[client_name]) {
+      processClient(namespace)
+    }
+
+    /*
+      special case when we don't have routes for a base resource
+      and thus a respective x-fern-sdk-group-name for ex. /noise_sensors
+    */
+    if (base_resource && !clients[pascalCase(base_resource)]) {
+      processClient(base_resource)
+    }
+
+    const client = clients[client_name]
+
+    if (!client) {
+      console.warn(`No client for "${client_name}", skipping`)
+      continue
+    }
+
+    const { parameter_schema, response_obj_type, response_arr_type } =
+      getParameterAndResponseSchema(route)
+
+    if (!parameter_schema) {
+      console.warn(`No parameter schema for "${route.path}", skipping`)
+      continue
+    }
+
+    const return_resource = response_obj_type ?? response_arr_type ?? ""
+
+    client.addMethod({
+      method_name: route.post["x-fern-sdk-method-name"],
+      path: route.path,
+      parameters: Object.entries(parameter_schema.properties)
+        .filter(
+          ([_, param_val]) =>
+            "type" in param_val ||
+            ("oneOf" in param_val && "type" in (param_val.oneOf[0] ?? {}))
+        )
+        .map(([param_name, param_val]: any) => ({
+          name: param_name,
+          type: getPhpType(param_val?.type ?? param_val.oneOf[0].type),
+          required: parameter_schema.required?.includes(param_name),
+          position:
+            route.post["x-fern-sdk-method-name"] === "get" &&
+            param_name === `${route.post["x-fern-sdk-return-value"]}_id`
+              ? 0
+              : undefined,
+        })),
+      return_path: route.post["x-fern-sdk-return-value"],
+      return_resource: pascalCase(return_resource),
+      is_array_response: Boolean(response_arr_type),
+    })
+  }
+
+  fs["src/SeamClient.php"] = generateSeamClient({
+    resource_clients: Object.values(clients),
+    resource_object_names: base_resource_object_names,
+  })
+
+  return fs
+}

package/src/lib/generate-php-sdk/index.ts

@@ -0,0 +1 @@
+export * from "./generate-php-sdk.js"

package/src/lib/generate-php-sdk/templates/composer.json.template.ts

@@ -0,0 +1,24 @@
+export default () => `{
+  "name": "seamapi/seam",
+  "type": "library",
+  "require": {
+    "guzzlehttp/guzzle": "^7.5"
+  },
+  "autoload": {
+    "psr-4": {
+      "Seam\\\\": "src/",
+      "Tests\\\\": "tests/"
+    }
+  },
+  "authors": [
+    {
+      "name": "seveibar",
+      "email": "seveibar@gmail.com"
+    }
+  ],
+  "require-dev": {
+    "phpunit/phpunit": "^9.5",
+    "squizlabs/php_codesniffer": "^3.7"
+  }
+}
+`

package/src/lib/generate-php-sdk/templates/env.example.template.ts

@@ -0,0 +1,3 @@
+export default () => `# API Key for a sandbox workspace
+SEAM_API_KEY=
+`

package/src/lib/generate-php-sdk/templates/gitignore.template.ts

@@ -0,0 +1,5 @@
+export default () => `vendor
+node_modules
+.env
+.vscode
+`

package/src/lib/generate-php-sdk/templates/package.json.template.ts

@@ -0,0 +1,11 @@
+export default () => `{
+  "name": "sdk1",
+  "version": "1.0.0",
+  "main": "index.js",
+  "license": "MIT",
+  "devDependencies": {
+    "@prettier/plugin-php": "^0.19.0",
+    "prettier": "^2.7.1"
+  }
+}
+`

package/src/lib/generate-php-sdk/templates/readme.md.template.ts

@@ -0,0 +1,85 @@
+export default () => `# Seam PHP SDK
+
+Control locks, lights and other internet of things devices with Seam's simple API.
+
+Check out [the documentation](https://docs.seam.co) or the usage below.
+
+## Usage
+
+\`\`\`php
+$seam = new Seam\SeamClient("YOUR_API_KEY");
+
+# Create a Connect Webview to login to a provider
+$connect_webview = $seam->connect_webviews->create(
+  accepted_providers: ["august"]
+);
+
+print "Please Login at this url: " . $connect_webview->url;
+
+# Poll until connect webview is completed
+while (true) {
+  $connect_webview = $seam->connect_webviews->get(
+    $connect_webview->connect_webview_id
+  );
+  if ($connect_webview->status == "authorized") {
+    break;
+  } else {
+    sleep(1);
+  }
+}
+
+$connected_account = $seam->connected_accounts->get(
+  $connect_webview->connected_account_id
+);
+
+print "Looks like you connected with " .
+  json_encode($connected_account->user_identifier);
+
+$devices = $seam->devices->list(
+  connected_account_id: $connected_account->connected_account_id
+);
+
+print "You have " . count($devices) . " devices";
+
+$device_id = $devices[0]->device_id;
+
+# Lock a Door
+$seam->locks->lock_door($device_id);
+
+$updated_device = $seam->devices->get($device_id);
+$updated_device->properties->locked; // true
+
+# Unlock a Door
+$seam->locks->unlock_door($device_id);
+$updated_device->properties->locked; // false
+
+# Create an access code on a device
+$access_code = $seam->access_codes->create(
+  device_id: $device_id,
+  code: "1234",
+  name: "Test Code"
+);
+
+# Check the status of an access code
+$access_code->status; // 'setting' (it will go to 'set' when active on the device)
+
+$seam->access_codes->delete($access_code->access_code_id);
+\`\`\`
+
+## Installation
+
+Run \`composer require seamapi/seam\`
+
+## Development Setup
+
+1. Run \`yarn install\` to get prettier installed for formatting
+2. Install [composer](https://getcomposer.org/).
+3. Run \`composer install\` in this directory
+4. Run \`composer exec phpunit tests\`
+
+> To run a specific test file, do \`composer exec phpunit tests/MyTest.php\`
+
+### Running Tests
+
+You'll need to export \`SEAM_API_KEY\` to a sandbox workspace API key.
+`

package/src/lib/generate-php-sdk/templates/smoke-test.template.ts

@@ -0,0 +1,29 @@
+export default () => `<?php
+
+declare(strict_types=1);
+
+use PHPUnit\\Framework\\TestCase;
+use Tests\\Fixture;
+
+final class SmokeTest extends TestCase
+{
+  public function testGetDevices(): void
+  {
+    $seam = Fixture::getTestSeamClient();
+
+    $devices_response = $seam->devices->list();
+    $this->assertIsString($devices_response[0]->device_id);
+  }
+  public function testCreateAccessCode(): void
+  {
+    $seam = Fixture::getTestSeamClient();
+
+    $access_code = $seam->access_codes->create(
+      device_id:"august_device_1", code:"1234"
+    );
+
+    $this->assertTrue($access_code->status === "setting");
+    $this->assertTrue($access_code->code === "1234");
+  }
+}
+`

package/src/lib/generate-php-sdk/templates/test-fixture.template.ts

@@ -0,0 +1,20 @@
+export default () => `<?php
+
+namespace Tests;
+
+use Seam\\SeamClient;
+
+final class Fixture
+{
+  public static function getTestSeamClient()
+  {
+    $random_string = substr(str_shuffle('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'), 0, 10);
+    $api_url = "https://{$random_string}.fakeseamconnect.seam.vc";
+    $api_key = "seam_apikey1_token";
+
+    $seam = new SeamClient($api_key, $api_url);
+
+    return $seam;
+  }
+}
+`

package/src/lib/generate-php-sdk/utils/deep-extract-resource-object-schemas.ts

@@ -0,0 +1,160 @@
+import type { OpenAPISchema, PropertySchema } from "lib/types.js"
+import { deepFlattenOneOfAndAllOfSchema } from "./deep-flatten-one-of-and-all-of-schema.js"
+import { pascalCase } from "change-case"
+
+type DeepExtractResourceObjectSchemasParams = {
+  schema_name: string
+  schema_body: OpenAPISchema["components"]["schemas"][string]
+}
+
+type ExtractedResourceObjectSchema = {
+  name: string
+  properties: Record<string, PropertySchemaWithReferenceObject>
+  required_property_names: string[]
+}
+
+type CreateResourceSchemaParams = {
+  name: string
+  properties: ResourceSchemaProperties
+  required_property_names?: string[]
+}
+type ResourceSchemaProperties = Record<
+  string,
+  PropertySchemaWithReferenceObject
+>
+
+export type PropertySchemaWithReferenceObject =
+  | PropertySchema
+  | {
+      type: "object" | "array"
+      reference_object_type_name?: string
+    }
+
+export function deepExtractResourceObjectSchemas({
+  schema_name,
+  schema_body,
+}: DeepExtractResourceObjectSchemasParams) {
+  const extracted_resource_objects_schemas: Record<
+    string,
+    ExtractedResourceObjectSchema
+  > = {}
+
+  function createResourceSchema({
+    name,
+    properties,
+    required_property_names = [],
+  }: CreateResourceSchemaParams) {
+    if (!extracted_resource_objects_schemas[name]) {
+      extracted_resource_objects_schemas[name] = {
+        name: pascalCase(name),
+        properties: processPropertySchemas(properties),
+        required_property_names: required_property_names,
+      }
+    }
+  }
+
+  function processPropertySchemas(
+    property_schemas: ResourceSchemaProperties
+  ): Record<string, PropertySchemaWithReferenceObject> {
+    const property_schemas_with_type_references: Record<
+      string,
+      PropertySchemaWithReferenceObject
+    > = {}
+
+    for (const property_name in property_schemas) {
+      const property_schema = property_schemas[property_name] as PropertySchema
+      const reference_object_type_name = pascalCase(
+        `${schema_name}_${property_name}`
+      )
+      if ("$ref" in property_schema) {
+        console.error("$ref not currently supported when extracting schemas")
+        continue
+      }
+
+      const is_all_of_or_one_of_schema =
+        "allOf" in property_schema || "oneOf" in property_schema
+      const is_object_schema =
+        !is_all_of_or_one_of_schema &&
+        property_schema.type === "object" &&
+        "properties" in property_schema
+      const is_array_non_primitive_schema =
+        !is_all_of_or_one_of_schema &&
+        property_schema.type === "array" &&
+        "items" in property_schema &&
+        "properties" in property_schema.items
+
+      if (is_object_schema) {
+        property_schemas_with_type_references[property_name] = {
+          type: "object",
+          reference_object_type_name,
+        }
+
+        createResourceSchema({
+          name: reference_object_type_name,
+          properties: property_schema.properties,
+          required_property_names: property_schema?.required,
+        })
+      } else if (is_array_non_primitive_schema) {
+        property_schemas_with_type_references[property_name] = {
+          type: "array",
+          reference_object_type_name,
+        }
+
+        createResourceSchema({
+          name: reference_object_type_name,
+          properties: (property_schema.items as any).properties,
+          required_property_names: (property_schema.items as any)?.required,
+        })
+      } else if (is_all_of_or_one_of_schema) {
+        const flattened_schema = deepFlattenOneOfAndAllOfSchema(property_schema)
+
+        if ("properties" in flattened_schema) {
+          property_schemas_with_type_references[property_name] = {
+            type: flattened_schema.type,
+            reference_object_type_name,
+          }
+
+          createResourceSchema({
+            name: reference_object_type_name,
+            properties: flattened_schema.properties,
+            required_property_names: flattened_schema?.required,
+          })
+        } else {
+          property_schemas_with_type_references[property_name] =
+            flattened_schema
+        }
+        continue
+      } else {
+        property_schemas_with_type_references[property_name] = {
+          type: property_schema.type as any,
+        }
+      }
+    }
+
+    return property_schemas_with_type_references
+  }
+
+  let base_resource_properties
+
+  if ("allOf" in schema_body || "oneOf" in schema_body) {
+    const flattened_base_resource_schema =
+      deepFlattenOneOfAndAllOfSchema(schema_body)
+
+    base_resource_properties =
+      "properties" in flattened_base_resource_schema
+        ? flattened_base_resource_schema.properties
+        : {}
+  }
+
+  base_resource_properties ??=
+    "properties" in schema_body ? schema_body.properties : {}
+
+  createResourceSchema({
+    name: pascalCase(schema_name),
+    properties: base_resource_properties as ResourceSchemaProperties,
+    required_property_names:
+      "required" in schema_body ? schema_body.required : [],
+  })
+
+  return extracted_resource_objects_schemas
+}