@seamapi/nextlove-sdk-generator 1.4.1 → 1.5.0

package/lib/generate-swift-sdk/templates/seamclient.swift.template.js

@@ -0,0 +1,73 @@
+import { camelCase } from "change-case";
+export default ({ namespaceToRouteGroupClassName, }) => `import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+enum SeamClientError: Error {
+  case couldNotMakeRequest(request: URLRequest, error: Error)
+  case non2xxResponseData(response: URLResponse, errorType: String?, errorMessage: String?, requestID: String?)
+  case responseJSONDecodingError(error: DecodingError)
+  case unknown(error: Error)
+}
+
+class SeamClient {
+  var apiKey: String
+  var baseURL: URL
+  let decoder = JSONDecoder()
+  let urlSession = URLSession.init(configuration: .default)
+
+  ${Array.from(namespaceToRouteGroupClassName.entries())
+    .map(([namespace, route_group_class_name]) => `var ${camelCase(namespace)}: ${route_group_class_name}! = nil`)
+    .join("\n  ")}
+
+  init(apiKey: String, baseURL: URL = URL(string: "https://connect.getseam.com")!) {
+    self.apiKey = apiKey
+    self.baseURL = baseURL
+
+    ${Array.from(namespaceToRouteGroupClassName.entries())
+    .map(([namespace, route_group_class_name]) => `self.${camelCase(namespace)} = ${route_group_class_name}(client: self)`)
+    .join("\n    ")}
+  }
+
+  func request<ResponseSchema: Decodable>(method: String, path: String, responseSchema: ResponseSchema.Type, jsonBody: Data? = nil) async -> Result<ResponseSchema, SeamClientError> {
+    let url = self.baseURL.appendingPathComponent(path)
+    var request = URLRequest(url: url)
+    request.httpMethod = method
+    request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+    request.setValue("Bearer \\(apiKey)", forHTTPHeaderField: "Authorization")
+
+    if let jsonBody = jsonBody {
+      request.httpBody = jsonBody
+    }
+
+    let requestResult: (Data, URLResponse)
+    do {
+      requestResult = try await self.urlSession.data(for: request)
+    } catch let error {
+      return .failure(.couldNotMakeRequest(request: request, error: error))
+    }
+    let (data, response) = requestResult
+
+    guard let httpResponse = response as? HTTPURLResponse,
+          (200...299).contains(httpResponse.statusCode) else {
+      // todo: better error
+      return .failure(.non2xxResponseData(
+        response: response,
+        errorType: nil,
+        errorMessage: nil,
+        requestID: nil
+      ))
+    }
+
+    do {
+      let decoded = try decoder.decode(ResponseSchema.self, from: data)
+      return .success(decoded)
+    } catch let error as DecodingError {
+      return .failure(.responseJSONDecodingError(error: error))
+    } catch let error {
+      return .failure(.unknown(error: error))
+    }
+  }
+}`;
+//# sourceMappingURL=seamclient.swift.template.js.map

package/lib/generate-swift-sdk/templates/seamclient.swift.template.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"seamclient.swift.template.js","sourceRoot":"","sources":["../../../src/lib/generate-swift-sdk/templates/seamclient.swift.template.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAMvC,eAAe,CAAC,EACd,8BAA8B,GACJ,EAAE,EAAE,CAAC;;;;;;;;;;;;;;;;;;IAkB7B,KAAK,CAAC,IAAI,CAAC,8BAA8B,CAAC,OAAO,EAAE,CAAC;KACnD,GAAG,CACF,CAAC,CAAC,SAAS,EAAE,sBAAsB,CAAC,EAAE,EAAE,CACtC,OAAO,SAAS,CAAC,SAAS,CAAC,KAAK,sBAAsB,SAAS,CAClE;KACA,IAAI,CAAC,MAAM,CAAC;;;;;;MAMX,KAAK,CAAC,IAAI,CAAC,8BAA8B,CAAC,OAAO,EAAE,CAAC;KACnD,GAAG,CACF,CAAC,CAAC,SAAS,EAAE,sBAAsB,CAAC,EAAE,EAAE,CACtC,QAAQ,SAAS,CACf,SAAS,CACV,MAAM,sBAAsB,gBAAgB,CAChD;KACA,IAAI,CAAC,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0CnB,CAAA"}

package/lib/types.d.ts

@@ -39,20 +39,25 @@ export type PrimitiveSchema = {
 } | {
     type: "boolean";
     enum?: boolean[];
+    nullable?: boolean;
 } | {
     type: "integer";
     enum?: number[];
+    nullable?: boolean;
 } | {
     type: "number";
+    nullable?: boolean;
 };
 export type ArraySchema = {
     type: "array";
     items: PropertySchema;
+    nullable?: boolean;
 };
 export type ObjSchema = {
     type: "object";
     properties: Record<string, PropertySchema>;
     required: string[];
+    nullable?: boolean;
 };
 export type RefSchema = {
     $ref: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seamapi/nextlove-sdk-generator",
-  "version": "1.4.1",
+  "version": "1.5.0",
   "description": "Utilities for building NextLove SDK Generators",
   "type": "module",
   "main": "index.js",
@@ -58,6 +58,7 @@
     "generate:ruby-sdk": "tsx ./scripts/generate-ruby-sdk.ts && prettier -w ./output/ruby",
     "generate:csharp-sdk": "tsx ./scripts/generate-csharp-sdk.ts && dotnet csharpier ./output/csharp",
     "generate:php-sdk": "tsx ./scripts/generate-php-sdk.ts && prettier -w ./output/php",
+    "generate:swift-sdk": "tsx ./scripts/generate-swift-sdk.ts && swiftformat .",
     "test:csharp-sdk": "dotnet test ./output/csharp"
   },
   "engines": {
@@ -69,6 +70,7 @@
     "axios": "^1.5.0",
     "change-case": "^4.1.2",
     "lodash": "^4.17.21",
+    "tsx": "^4.7.0",
     "yargs": "^17.7.2"
   },
   "devDependencies": {

package/src/index.ts

@@ -4,3 +4,4 @@ export * from "./lib/generate-csharp-sdk/generate-csharp-sdk.js"
 export * from "./lib/generate-python-sdk/index.js"
 export * from "./lib/generate-ruby-sdk/index.js"
 export * from "./lib/generate-php-sdk/index.js"
+export * from "./lib/generate-swift-sdk/generate-swift-sdk.js"

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

@@ -82,11 +82,15 @@ export function deepExtractResourceObjectSchemas({
         property_schema.type === "array" &&
         "items" in property_schema &&
         "properties" in property_schema.items
+      const is_nullable_set = "nullable" in property_schema
 
       if (is_object_schema) {
         property_schemas_with_type_references[property_name] = {
           type: "object",
           reference_object_type_name,
+          ...(is_nullable_set && {
+            nullable: property_schema.nullable,
+          }),
         }
 
         createResourceSchema({
@@ -98,6 +102,9 @@ export function deepExtractResourceObjectSchemas({
         property_schemas_with_type_references[property_name] = {
           type: "array",
           reference_object_type_name,
+          ...(is_nullable_set && {
+            nullable: property_schema.nullable,
+          }),
         }
 
         createResourceSchema({
@@ -127,6 +134,9 @@ export function deepExtractResourceObjectSchemas({
       } else {
         property_schemas_with_type_references[property_name] = {
           type: property_schema.type as any,
+          ...(is_nullable_set && {
+            nullable: property_schema.nullable,
+          }),
         }
       }
     }

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

@@ -26,11 +26,18 @@ export const generateResourceObjectClass = ({
       prop_schema.type === "array" &&
       "reference_object_type_name" in prop_schema
 
+    const is_property_required =
+      "nullable" in prop_schema
+        ? !prop_schema.nullable
+        : required_property_names.includes(prop_name)
+
     if (is_object_referencing_resource) {
       return `${prop_name}: ${
+        is_property_required ? "" : `isset($json->${prop_name}) ? `
+      }${
         prop_schema.reference_object_type_name
       }::from_json($json->${prop_name})${
-        required_property_names.includes(prop_name) ? "," : " ?? null,"
+        is_property_required ? "," : " : null,"
       }`
     } else if (is_array_referencing_resource) {
       return `${prop_name}: array_map(
@@ -39,7 +46,7 @@ export const generateResourceObjectClass = ({
         ),`
     } else {
       return `${prop_name}: $json->${prop_name}${
-        required_property_names.includes(prop_name) ? "," : " ?? null,"
+        is_property_required ? "," : " ?? null,"
       }`
     }
   }
@@ -74,13 +81,13 @@ export const generateResourceObjectClass = ({
             const php_type = is_object_referencing_resource
               ? prop_schema.reference_object_type_name
               : getPhpType("type" in prop_schema ? prop_schema.type : "mixed")
+            const is_property_required =
+              "nullable" in prop_schema
+                ? !prop_schema.nullable
+                : required_property_names.includes(prop_name)
 
             return `public ${php_type}${
-              php_type === "mixed"
-                ? ""
-                : required_property_names.includes(prop_name)
-                ? ""
-                : " | null"
+              php_type === "mixed" ? "" : is_property_required ? "" : " | null"
             } $${prop_name},`
           })
           .join("\n        ")}

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

@@ -0,0 +1,135 @@
+import axios from "axios"
+import type { ObjSchema, OpenAPISchema, Route } from "lib/types.js"
+import readmeMdTemplate from "./templates/readme.md.template.js"
+import packageSwiftTemplate from "./templates/package.swift.template.js"
+import seamClientSwiftTemplate from "./templates/seamclient.swift.template.js"
+import anyJsonSwiftTemplate from "./templates/anyjson.swift.template.js"
+import { pascalCase } from "change-case"
+import { flattenObjSchema, getParameterAndResponseSchema } from "lib/index.js"
+import { mapSwiftType } from "./map-swift-type.js"
+import { RouteGroupClassfile } from "./route-group-class-file.js"
+
+export const generateSwiftSDK = async () => {
+  const openapi: OpenAPISchema = await axios
+    .get("https://connect.getseam.com/openapi.json")
+    .then((res) => res.data)
+
+  const fs: Record<string, string> = {}
+
+  fs["README.md"] = readmeMdTemplate()
+  fs["Package.swift"] = packageSwiftTemplate()
+
+  const resources = Object.entries(openapi.components.schemas).map(
+    ([schema_name, schema]) =>
+      [schema_name, flattenObjSchema(schema as any)] as [string, ObjSchema]
+  )
+
+  fs["Sources/SeamAPI/AnyJSON.swift"] = anyJsonSwiftTemplate()
+
+  // Create a struct for each declared resource
+  fs["Sources/SeamAPI/Schemas.swift"] = [
+    "import Foundation",
+    ...resources
+      .map(([snake_name, schema]) => {
+        const props = Object.entries(schema.properties)
+          .map(([name, property_schema]) => {
+            const is_optional =
+              !schema.required?.includes(name) ||
+              (property_schema as any).nullable
+
+            return `let ${name}: ${mapSwiftType(property_schema, "AnyJSON")}${
+              is_optional ? "?" : ""
+            }`
+          })
+          .join("\n")
+
+        return `struct ${pascalCase(snake_name)}: Decodable {\n${props}\n}`
+      })
+      .filter((x) => x),
+  ].join("\n")
+
+  // Construct route groups by namespace
+  const namespaceToRouteGroupClassName = new Map<string, string>()
+
+  const routes: Route[] = Object.entries(openapi.paths).map(([path, v]) => ({
+    path,
+    ...v,
+  }))
+  const class_map: Record<string, RouteGroupClassfile> = {}
+  const namespaces: string[][] = []
+  for (const route of routes) {
+    if (!route.post) continue
+    if (!route.post["x-fern-sdk-group-name"]) continue
+    const group_names = [...route.post["x-fern-sdk-group-name"]]
+    const namespace = group_names.join("_")
+    group_names.reverse()
+    const class_name = pascalCase(group_names.join("_")) + "Routes"
+    if (!class_map[class_name]) {
+      namespaces.push(route.post["x-fern-sdk-group-name"])
+      class_map[class_name] = new RouteGroupClassfile(class_name, namespace)
+      namespaceToRouteGroupClassName.set(namespace, class_name)
+    }
+    const cls = class_map[class_name]
+
+    if (!cls) {
+      console.warn(`No class for "${route.path}", skipping`)
+      continue
+    }
+
+    const { parameter_schema, response_obj_type, response_arr_type } =
+      getParameterAndResponseSchema(route)
+
+    if (!response_obj_type && !response_arr_type) {
+      console.warn(`No response object/array ref for "${route.path}", skipping`)
+      continue
+    }
+
+    if (!parameter_schema) {
+      console.warn(`No parameter schema for "${route.path}", skipping`)
+      continue
+    }
+
+    cls.addMethod({
+      method_name: route.post["x-fern-sdk-method-name"],
+      path: route.path,
+      bodyParameters: Object.entries(parameter_schema.properties)
+        .filter(
+          ([_, param_val]) =>
+            param_val && typeof param_val === "object" && "type" in param_val
+        )
+        .map(([param_name, param_schema]) => {
+          const name = param_name
+          return {
+            name,
+            swiftType: mapSwiftType(param_schema),
+            isRequired: parameter_schema.required?.includes(name) ?? false,
+          }
+        }),
+      return_path: [route.post["x-fern-sdk-return-value"]],
+      return_resource: response_obj_type
+        ? pascalCase(response_obj_type)
+        : `[${pascalCase(response_arr_type)}]`,
+    })
+  }
+
+  const route_groups = Object.values(class_map).filter((r) => !r.isEmpty)
+
+  // Write all route groups
+  for (const route_group of route_groups) {
+    fs[`Sources/SeamAPI/Routes/${pascalCase(route_group.namespace!)}.swift`] =
+      route_group.serializeToClass()
+  }
+
+  // Remove route groups that were filtered out because they were empty
+  for (const namespace of namespaceToRouteGroupClassName.keys()) {
+    if (!route_groups.find((r) => r.namespace === namespace)) {
+      namespaceToRouteGroupClassName.delete(namespace)
+    }
+  }
+
+  fs["Sources/SeamAPI/SeamClient.swift"] = seamClientSwiftTemplate({
+    namespaceToRouteGroupClassName,
+  })
+
+  return fs
+}

package/src/lib/generate-swift-sdk/map-swift-type.ts

@@ -0,0 +1,27 @@
+import type { PropertySchema } from "lib/types.ts"
+
+export const mapSwiftType = (
+  property_schema: PropertySchema,
+  fallback = "String"
+) => {
+  if (typeof property_schema !== "object") {
+    return "Any"
+  }
+
+  if ("type" in property_schema && property_schema.type === "string") {
+    // todo: handle date-time
+    return "String"
+  }
+  if ("type" in property_schema && property_schema.type === "integer")
+    return "Int"
+  if ("type" in property_schema && property_schema.type === "boolean")
+    return "Bool"
+  if ("type" in property_schema && property_schema.type === "number")
+    return "Float"
+  if ("type" in property_schema && property_schema.type === "array")
+    return "[String]" // TODO, make more specific
+  if ("type" in property_schema && property_schema.type === "object")
+    return `[String: ${fallback}]` // TODO, make more specific
+
+  return fallback
+}

package/src/lib/generate-swift-sdk/route-group-class-file.ts

@@ -0,0 +1,89 @@
+export type RouteGroupClassfileMethod = {
+  method_name: string
+  path: string
+  bodyParameters: {
+    name: string
+    swiftType: string
+    isRequired: boolean
+  }[]
+  return_path: string[]
+  return_resource: string
+}
+
+export class RouteGroupClassfile {
+  private methods: RouteGroupClassfileMethod[] = []
+  constructor(
+    private name: string,
+    public namespace?: string
+  ) {}
+
+  addMethod(method: RouteGroupClassfileMethod) {
+    this.methods.push(method)
+  }
+
+  get isEmpty() {
+    return this.methods.length === 0
+  }
+
+  serializeToClass() {
+    return `import Foundation
+    #if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+    class ${this.name} {
+  private let client: SeamClient
+  init(client: SeamClient) {
+    self.client = client
+  }
+
+${this.methods
+  .map(
+    ({ method_name, bodyParameters, path, return_path, return_resource }) =>
+      `  func ${method_name}(${bodyParameters
+        .map(({ name, swiftType, isRequired }) =>
+          isRequired ? `${name}: ${swiftType}` : `${name}: ${swiftType}? = nil`
+        )
+        .join(", ")}) async -> Result<${return_resource}, SeamClientError> {
+    ${bodyParameters.length > 0 ? "var" : "let"} jsonBody: [String: Any] = [:]
+
+${bodyParameters
+  .map(({ name, isRequired }) =>
+    isRequired
+      ? `jsonBody["${name}"] = ${name}`
+      : `    if let ${name} = ${name} {
+      jsonBody["${name}"] = ${name}
+    }`
+  )
+  .join("\n\n")}
+
+    let encodedJsonBody: Data?
+    do {
+      encodedJsonBody = try JSONSerialization.data(withJSONObject: jsonBody, options: [])
+    } catch let error {
+      return .failure(.unknown(error: error))
+    }
+
+    struct Response: Decodable {
+      let ${return_path[0]}: ${return_resource}
+    }
+
+    let response = await client.request(
+      method: "POST",
+      path: "${path}",
+      responseSchema: Response.self,
+      jsonBody: encodedJsonBody
+    )
+
+    switch response {
+    case .success(let response):
+      return .success(response.${return_path[0]})
+    case .failure(let error):
+      return .failure(error)
+    }
+  }`
+  )
+  .join("\n\n")}
+}`.trim()
+  }
+}

package/src/lib/generate-swift-sdk/templates/anyjson.swift.template.ts

@@ -0,0 +1,167 @@
+export default () => `// Thanks to https://adamrackis.dev/blog/swift-codable-any
+import Foundation
+
+func decode(fromObject container: KeyedDecodingContainer<AnyJSONCodingKeys>) -> [String: Any] {
+  var result: [String: Any] = [:]
+
+  for key in container.allKeys {
+    if let val = try? container.decode(Int.self, forKey: key) {
+      result[key.stringValue] = val
+    } else if let val = try? container.decode(Double.self, forKey: key) {
+      result[key.stringValue] = val
+    } else if let val = try? container.decode(String.self, forKey: key) {
+      result[key.stringValue] = val
+    } else if let val = try? container.decode(Bool.self, forKey: key) {
+      result[key.stringValue] = val
+    } else if let nestedContainer = try? container.nestedContainer(
+      keyedBy: AnyJSONCodingKeys.self, forKey: key)
+    {
+      result[key.stringValue] = decode(fromObject: nestedContainer)
+    } else if var nestedArray = try? container.nestedUnkeyedContainer(forKey: key) {
+      result[key.stringValue] = decode(fromArray: &nestedArray)
+    } else if (try? container.decodeNil(forKey: key)) == true {
+      result.updateValue(Any?(nil) as Any, forKey: key.stringValue)
+    }
+  }
+
+  return result
+}
+
+func decode(fromArray container: inout UnkeyedDecodingContainer) -> [Any] {
+  var result: [Any] = []
+
+  while !container.isAtEnd {
+    if let value = try? container.decode(String.self) {
+      result.append(value)
+    } else if let value = try? container.decode(Int.self) {
+      result.append(value)
+    } else if let value = try? container.decode(Double.self) {
+      result.append(value)
+    } else if let value = try? container.decode(Bool.self) {
+      result.append(value)
+    } else if let nestedContainer = try? container.nestedContainer(keyedBy: AnyJSONCodingKeys.self) {
+      result.append(decode(fromObject: nestedContainer))
+    } else if var nestedArray = try? container.nestedUnkeyedContainer() {
+      result.append(decode(fromArray: &nestedArray))
+    } else if (try? container.decodeNil()) == true {
+      result.append(Any?(nil) as Any)
+    }
+  }
+
+  return result
+}
+
+func encodeValue(
+  fromObjectContainer container: inout KeyedEncodingContainer<AnyJSONCodingKeys>, map: [String: Any]
+) throws {
+  for k in map.keys {
+    let value = map[k]
+    let encodingKey = AnyJSONCodingKeys(stringValue: k)
+
+    if let value = value as? String {
+      try container.encode(value, forKey: encodingKey)
+    } else if let value = value as? Int {
+      try container.encode(value, forKey: encodingKey)
+    } else if let value = value as? Double {
+      try container.encode(value, forKey: encodingKey)
+    } else if let value = value as? Bool {
+      try container.encode(value, forKey: encodingKey)
+    } else if let value = value as? [String: Any] {
+      var keyedContainer = container.nestedContainer(
+        keyedBy: AnyJSONCodingKeys.self, forKey: encodingKey)
+      try encodeValue(fromObjectContainer: &keyedContainer, map: value)
+    } else if let value = value as? [Any] {
+      var unkeyedContainer = container.nestedUnkeyedContainer(forKey: encodingKey)
+      try encodeValue(fromArrayContainer: &unkeyedContainer, arr: value)
+    } else {
+      try container.encodeNil(forKey: encodingKey)
+    }
+  }
+}
+
+func encodeValue(fromArrayContainer container: inout UnkeyedEncodingContainer, arr: [Any]) throws {
+  for value in arr {
+    if let value = value as? String {
+      try container.encode(value)
+    } else if let value = value as? Int {
+      try container.encode(value)
+    } else if let value = value as? Double {
+      try container.encode(value)
+    } else if let value = value as? Bool {
+      try container.encode(value)
+    } else if let value = value as? [String: Any] {
+      var keyedContainer = container.nestedContainer(keyedBy: AnyJSONCodingKeys.self)
+      try encodeValue(fromObjectContainer: &keyedContainer, map: value)
+    } else if let value = value as? [Any] {
+      var unkeyedContainer = container.nestedUnkeyedContainer()
+      try encodeValue(fromArrayContainer: &unkeyedContainer, arr: value)
+    } else {
+      try container.encodeNil()
+    }
+  }
+}
+
+
+
+struct AnyJSONCodingKeys: CodingKey {
+  var stringValue: String
+
+  init(stringValue: String) {
+    self.stringValue = stringValue
+  }
+
+  var intValue: Int?
+
+  init?(intValue: Int) {
+    self.init(stringValue: "\(intValue)")
+    self.intValue = intValue
+  }
+}
+
+struct AnyJSON: Codable {
+  var value: Any?
+
+  init(value: Any?) {
+    self.value = value
+  }
+  init(from decoder: Decoder) throws {
+    if let container = try? decoder.container(keyedBy: AnyJSONCodingKeys.self) {
+      self.value = decode(fromObject: container)
+    } else if var array = try? decoder.unkeyedContainer() {
+      self.value = decode(fromArray: &array)
+    } else if let value = try? decoder.singleValueContainer() {
+      if value.decodeNil() {
+        self.value = nil
+      } else {
+        if let result = try? value.decode(Int.self) { self.value = result }
+        if let result = try? value.decode(Double.self) { self.value = result }
+        if let result = try? value.decode(String.self) { self.value = result }
+        if let result = try? value.decode(Bool.self) { self.value = result }
+      }
+    }
+  }
+
+  func encode(to encoder: Encoder) throws {
+    if let map = self.value as? [String: Any] {
+      var container = encoder.container(keyedBy: AnyJSONCodingKeys.self)
+      try encodeValue(fromObjectContainer: &container, map: map)
+    } else if let arr = self.value as? [Any] {
+      var container = encoder.unkeyedContainer()
+      try encodeValue(fromArrayContainer: &container, arr: arr)
+    } else {
+      var container = encoder.singleValueContainer()
+
+      if let value = self.value as? String {
+        try! container.encode(value)
+      } else if let value = self.value as? Int {
+        try! container.encode(value)
+      } else if let value = self.value as? Double {
+        try! container.encode(value)
+      } else if let value = self.value as? Bool {
+        try! container.encode(value)
+      } else {
+        try! container.encodeNil()
+      }
+    }
+  }
+}`

package/src/lib/generate-swift-sdk/templates/package.swift.template.ts

@@ -0,0 +1,27 @@
+export default () => `// swift-tools-version: 5.7
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "SeamAPI",
+    platforms: [
+      .macOS(.v12)
+    ],
+    products: [
+        // Products define the executables and libraries a package produces, making them visible to other packages.
+        .library(
+            name: "SeamAPI",
+            targets: ["SeamAPI"]),
+    ],
+    targets: [
+        // Targets are the basic building blocks of a package, defining a module or a test suite.
+        // Targets can depend on other targets in this package and products from dependencies.
+        .target(
+            name: "SeamAPI"),
+        .testTarget(
+            name: "SeamAPITests",
+            dependencies: ["SeamAPI"]),
+    ]
+)
+`