@oatfi/oatfi-sdk-ts 0.4.0

package/.devcontainer/README.md

@@ -0,0 +1,30 @@
+
+> **Remember to shutdown a GitHub Codespace when it is not in use!**
+
+# Dev Containers Quick Start
+
+The default location for usage snippets is the `samples` directory.
+
+## Running a Usage Sample
+
+A sample usage example has been provided in a `root.ts` file. As you work with the SDK, it's expected that you will modify these samples to fit your needs. To execute this particular snippet, use the command below.
+
+```
+ts-node root.ts
+```
+
+## Generating Additional Usage Samples
+
+The speakeasy CLI allows you to generate more usage snippets. Here's how:
+
+- To generate a sample for a specific operation by providing an operation ID, use:
+
+```
+speakeasy generate usage -s .speakeasy/out.openapi.yaml -l typescript -i {INPUT_OPERATION_ID} -o ./samples
+```
+
+- To generate samples for an entire namespace (like a tag or group name), use:
+
+```
+speakeasy generate usage -s .speakeasy/out.openapi.yaml -l typescript -n {INPUT_TAG_NAME} -o ./samples
+```

package/.devcontainer/devcontainer.json

@@ -0,0 +1,45 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the
+// README at: https://github.com/devcontainers/images/tree/main/src/typescript-node
+{
+    "name": "TypeScript",
+    "image": "mcr.microsoft.com/devcontainers/typescript-node:1-20-bullseye",
+    // Features to add to the dev container. More info: https://containers.dev/features.
+    // "features": {},
+    // Use 'forwardPorts' to make a list of ports inside the container available locally.
+    // "forwardPorts": [],
+    // Use 'postCreateCommand' to run commands after the container is created.
+    "postCreateCommand": "sudo chmod +x ./.devcontainer/setup.sh && ./.devcontainer/setup.sh",
+    "customizations": {
+        "vscode": {
+            "extensions": [
+                "ms-vscode.vscode-typescript-tslint-plugin",
+                "esbenp.prettier-vscode",
+                "github.vscode-pull-request-github"
+            ],
+            "settings": {
+                "files.eol": "\n",
+                "editor.formatOnSave": true,
+                "typescript.tsc.autoDetect": "on",
+                "typescript.updateImportsOnFileMove.enabled": "always",
+                "typescript.preferences.importModuleSpecifier": "relative",
+                "[typescript]": {
+                    "editor.codeActionsOnSave": {
+                        "source.organizeImports": true
+                    }
+                },
+                "[typescriptreact]": {
+                    "editor.codeActionsOnSave": {
+                        "source.organizeImports": true
+                    }
+                }
+            }
+        },
+        "codespaces": {
+            "openFiles": [
+                ".devcontainer/README.md"
+            ]
+        }
+    }
+    // Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
+    // "remoteUser": "root"
+}

package/FUNCTIONS.md

@@ -0,0 +1,159 @@
+# Standalone Functions
+
+> [!NOTE]
+> This section is useful if you are using a bundler and targetting browsers and
+> runtimes where the size of an application affects performance and load times. 
+
+Every method in this SDK is also available as a standalone function. This
+alternative API is suitable when targetting the browser or serverless runtimes
+and using a bundler to build your application since all unused functionality
+will be tree-shaken away. This includes code for unused methods, Zod schemas,
+encoding helpers and response handlers. The result is dramatically smaller
+impact on the application's final bundle size which grows very slowly as you use
+more and more functionality from this SDK.
+
+Calling methods through the main SDK class remains a valid and generally more
+more ergonomic option. Standalone functions represent an optimisation for a
+specific category of applications.
+
+## Example
+
+```typescript
+import { OatFiSDKCore } from "@oatfi/oatfi-sdk-ts/core.js";
+import { applicationsCreate } from "@oatfi/oatfi-sdk-ts/funcs/applicationsCreate.js";
+
+// Use `OatFiSDKCore` for best tree-shaking performance.
+// You can create one instance of it to use across an application.
+const oatFiSDK = new OatFiSDKCore({
+  bearer: process.env["OATFISDK_BEARER"] ?? "",
+});
+
+async function run() {
+  const res = await applicationsCreate(oatFiSDK, {
+    idempotencyKey: "<value>",
+    createApplicationDto: {
+      platform: "<value>",
+      businessInformation: {
+        name: "Acme Corp",
+        externalId: "biz_123abc",
+        dbaName: "Acme Innovations",
+        taxId: "123456789",
+        businessEntityType: "corporation",
+        stateOfIncorporation: "CA",
+        dateEstablished: "2020-01-15",
+        physicalAddress: {
+          line1: "123 Main St",
+          line2: "Apt 4B",
+          city: "San Francisco",
+          state: "CA",
+          postalCode: "94107",
+        },
+        contactPhone: "555-123-4567",
+        contactEmail: "contact@acme.com",
+        industryType: "541511",
+        businessDescription: "Software development services",
+        websiteUrl: "https://acme.com",
+        mailingAddress: {
+          line1: "123 Main St",
+          line2: "Apt 4B",
+          city: "San Francisco",
+          state: "CA",
+          postalCode: "94107",
+        },
+      },
+      personsInformation: [
+        {
+          externalId: "person_ext_123",
+          firstName: "John",
+          lastName: "Doe",
+          title: "CEO",
+          email: "john.doe@example.com",
+          phone: "555-0101",
+          dateOfBirth: "1985-07-22",
+          address: {
+            line1: "123 Main St",
+            line2: "Apt 4B",
+            city: "San Francisco",
+            state: "CA",
+            postalCode: "94107",
+          },
+          relationshipToBusiness: "Owner",
+          isControlPerson: false,
+          ownershipPercentage: 25,
+          kycStatus: "NOT_STARTED",
+          ssn: "123-45-6789",
+        },
+      ],
+      expectedUsage: {
+        expectedMonthlyPaymentsVolumeRange: "100,001-500,000",
+        operationalCountries: [
+          "US",
+          "CA",
+        ],
+        customerTypes: [
+          "B2C",
+          "B2B",
+        ],
+        fundsTransferCountries: [
+          "US",
+          "MX",
+        ],
+        restrictedActivities: {},
+      },
+    },
+  });
+  if (res.ok) {
+    const { value: result } = res;
+    console.log(result);
+  } else {
+    console.log("applicationsCreate failed:", res.error);
+  }
+}
+
+run();
+```
+
+## Result types
+
+Standalone functions differ from SDK methods in that they return a
+`Result<Value, Error>` type to capture _known errors_ and document them using
+the type system. By avoiding throwing errors, application code maintains clear
+control flow and error-handling become part of the regular flow of application
+code.
+
+> We use the term "known errors" because standalone functions, and JavaScript
+> code in general, can still throw unexpected errors such as `TypeError`s,
+> `RangeError`s and `DOMException`s. Exhaustively catching all errors may be
+> something this SDK addresses in the future. Nevertheless, there is still a lot
+> of benefit from capturing most errors and turning them into values.
+
+The second reason for this style of programming is because these functions will
+typically be used in front-end applications where exception throwing is
+sometimes discouraged or considered unidiomatic. React and similar ecosystems
+and libraries tend to promote this style of programming so that components
+render useful content under all states (loading, success, error and so on).
+
+The general pattern when calling standalone functions looks like this:
+
+```typescript
+import { Core } from "<sdk-package-name>";
+import { fetchSomething } from "<sdk-package-name>/funcs/fetchSomething.js";
+
+const client = new Core();
+
+async function run() {
+  const result = await fetchSomething(client, { id: "123" });
+  if (!result.ok) {
+    // You can throw the error or handle it. It's your choice now.
+    throw result.error;
+  }
+
+  console.log(result.value);
+}
+
+run();
+```
+
+Notably, `result.error` above will have an explicit type compared to a try-catch
+variation where the error in the catch block can only be of type `unknown` (or
+`any` depending on your TypeScript settings).