@palmetto/users-sdk 0.0.1

package/dist/client.d.ts

@@ -0,0 +1,41 @@
+export interface CreateClientOptions {
+    apiUrl: string;
+    authToken?: string;
+}
+export interface ApiOptions {
+    authToken?: string;
+    headers?: Record<string, string>;
+}
+export declare class UsersApiClient {
+    private api;
+    private fetcher;
+    private headers;
+    constructor(opts: CreateClientOptions);
+    setAuthToken(authToken: string): void;
+    me(opts?: ApiOptions): Promise<import("./result").ResultOk<import("openapi-typescript-fetch").ApiResponse<{
+        auth0Id: string;
+        email: string;
+        grants: {
+            entity: string;
+            operation: string;
+            deny?: boolean;
+        }[];
+        id: string;
+        firstName: string;
+        lastName: string;
+        phoneNumber: string;
+        organizationId: unknown;
+        meta: {
+            createdAt: string;
+            updatedAt?: string;
+        };
+    }>> | import("./result").ResultErr<{
+        code: "NOT_AUTHENTICATED";
+    }> | import("./result").ResultErr<{
+        error: unknown;
+    } & {
+        code: "UNKNOWN_ERROR";
+    }>>;
+    protected generateRequestInit(opts?: ApiOptions): RequestInit;
+    protected mergeHeaders(overrides: Record<string, string>): Headers;
+}

package/dist/client.js

@@ -0,0 +1,59 @@
+import { ApiError, 
+// FetchArgType,
+Fetcher,
+// FetchReturnType,
+ } from "openapi-typescript-fetch";
+import { Ok, Err } from "./result";
+export class UsersApiClient {
+    api;
+    fetcher;
+    headers;
+    constructor(opts) {
+        this.fetcher = Fetcher.for();
+        this.fetcher.configure({ baseUrl: opts.apiUrl });
+        this.headers = new Headers();
+        if (opts.authToken) {
+            this.setAuthToken(opts.authToken);
+        }
+        this.api = {
+            me: this.fetcher.path("/api/users/me").method("get").create(),
+        };
+    }
+    setAuthToken(authToken) {
+        this.headers.set("Authorization", `Bearer ${authToken}`);
+    }
+    async me(opts) {
+        try {
+            const response = await this.api.me(undefined, this.generateRequestInit(opts));
+            return Ok(response);
+        }
+        catch (err) {
+            if (err instanceof ApiError) {
+                switch (err.status) {
+                    case 401:
+                        return Err("NOT_AUTHENTICATED");
+                }
+            }
+            return Err("UNKNOWN_ERROR", { error: err });
+        }
+    }
+    generateRequestInit(opts) {
+        const headers = opts?.headers
+            ? this.mergeHeaders(opts.headers)
+            : new Headers(this.headers);
+        if (opts?.authToken) {
+            headers.set("Authorization", `Bearer ${opts.authToken}`);
+        }
+        return { headers };
+    }
+    mergeHeaders(overrides) {
+        const merged = new Headers(this.headers);
+        for (const key in overrides) {
+            merged.set(key, overrides[key]);
+        }
+        return merged;
+    }
+}
+// type ApiClient = InstanceType<typeof UsersApiClient>["api"];
+// type ResponseType<T extends keyof ApiClient> = FetchReturnType<ApiClient[T]>;
+// type InputType<T extends keyof ApiClient> = FetchArgType<ApiClient[T]>;

package/dist/main.d.ts

@@ -0,0 +1 @@
+export * from "./client";

package/dist/main.js

@@ -0,0 +1 @@
+export * from "./client";

package/dist/result.d.ts

@@ -0,0 +1,19 @@
+export interface ResultOk<TData = unknown> {
+    ok: true;
+    data: TData;
+}
+export interface ResultErr<TError = unknown> {
+    ok: false;
+    error: TError;
+}
+export type Result<TData = unknown, TError = unknown> = ResultOk<TData> | ResultErr<TError>;
+export type inferResultData<TResult extends Result> = TResult extends ResultOk<infer TData> ? TData : never;
+export type inferResultError<TResult extends Result> = TResult extends ResultErr<infer TError> ? TError : never;
+export declare function Err<TCode extends string>(code: TCode): ResultErr<{
+    code: TCode;
+}>;
+export declare function Err<TCode extends string, TExtra extends Record<string, unknown>>(code: TCode, extra: TExtra): ResultErr<TExtra & {
+    code: TCode;
+}>;
+export declare function Ok<TData = unknown>(data: TData): ResultOk<TData>;
+export declare function assertOk(result: Result): asserts result is ResultOk;

package/dist/result.js

@@ -0,0 +1,11 @@
+export function Err(code, extra) {
+    return { ok: false, error: { ...extra, code } };
+}
+export function Ok(data) {
+    return { ok: true, data };
+}
+export function assertOk(result) {
+    if (!result.ok) {
+        throw new Error("Result was an error!");
+    }
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@palmetto/users-sdk",
+  "version": "0.0.1",
+  "main": "./dist/main.js",
+  "files": [
+    "dist/**/*"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc",
+    "tc": "tsc --noEmit",
+    "generate": "node ./scripts/generateApiSchema.mjs"
+  },
+  "devDependencies": {
+    "@types/node": "^22.5.5",
+    "openapi-typescript": "^7.4.0",
+    "typescript": "5.5.4"
+  },
+  "dependencies": {
+    "openapi-typescript-fetch": "^2.0.0"
+  }
+}