Support new schema endpoint and metadata operations

README.md

@@ -1,6 +1,31 @@
 # Glide Tables Client
 
-## Usage
+## Authorization
+
+Set `GLIDE_TOKEN` environment variable or pass the token as props.
+
+## Apps
+
+```ts
+import * as glide from "@glideapps/tables";
+
+// Create a reference to an app using its ID
+const myApp = glide.app("bAFxpGXU1bHiBgUMcDgn");
+
+// Or get by name
+const myApp = await glide.getAppNamed("Employee Directory");
+
+// Get all tables
+const tables = await myApp.getTables();
+
+// Get a table by name
+const users = await myApp.getTableNamed("Users");
+
+// List all apps
+const apps = await glide.getApps();
+```
+
+## Tables
 
 ```ts
 import * as glide from "@glideapps/tables";
@@ -42,6 +67,9 @@ await inventory.setRow(rowID, {
 
 // Delete a row
 await inventory.deleteRow(rowID);
+
+// Get table schema info (columns and their types)
+const schema = await inventory.getSchema();
 ```
 
 ### Staging

package.json

@@ -19,6 +19,7 @@
     "@swc/core": "^1.3.44",
     "@swc/jest": "^0.2.24",
     "@types/jest": "^29.5.0",
+    "dotenv": "^16.3.1",
     "jest": "^29.5.0",
     "prettier": "^2.8.7",
     "semver": "^7.3.8",

src/index.ts

@@ -1,9 +1,12 @@
+import { Client, makeClient } from "./rest";
 import type { TableProps, Row, ColumnSchema, RowID, FullRow, AppProps } from "./types";
 
 import fetch from "cross-fetch";
 
 type RowIdentifiable<T extends ColumnSchema> = RowID | FullRow<T>;
 
+type IDName = { id: string; name: string };
+
 function rowID(row: RowIdentifiable<any>): RowID {
   return typeof row === "string" ? row : row.$rowID;
 }
@@ -18,19 +21,32 @@ const defaultEndpoint = "https://api.glideapp.io/api/function";
 class Table<T extends ColumnSchema> {
   private props: TableProps<T>;
 
+  private client: Client;
+
   public get app(): string {
     return this.props.app;
   }
 
+  public get id(): string {
+    return this.props.table;
+  }
+
   public get table(): string {
     return this.props.table;
   }
 
+  public get name() {
+    return this.props.name;
+  }
+
   constructor(props: TableProps<T>) {
     this.props = {
-      token: process.env.GLIDE_TOKEN,
       ...props,
+      token: props.token ?? process.env.GLIDE_TOKEN,
     };
+    this.client = makeClient({
+      token: process.env.GLIDE_TOKEN!,
+    });
   }
 
   private renameOutgoing(rows: Row<T>[]): Row<T>[] {
@@ -159,6 +175,20 @@ class Table<T extends ColumnSchema> {
     await this.deleteRows([row]);
   }
 
+  public async getSchema(): Promise<{
+    data: { columns: Array<{ id: string; name: string; type: { kind: string } }> };
+  }> {
+    const { app, table } = this.props;
+
+    const response = await this.client.get(`/apps/${app}/tables/${table}/schema`);
+
+    if (response.status !== 200) {
+      throw new Error(`Failed to get schema: ${response.status} ${response.statusText}`);
+    }
+
+    return await response.json();
+  }
+
   public async getRows(): Promise<FullRow<T>[]> {
     const { token, app, table } = this.props;
 
@@ -175,7 +205,12 @@ class Table<T extends ColumnSchema> {
     });
 
     if (!response.ok) {
-      throw new Error(`Failed to get rows: ${response.status} ${response.statusText}`);
+      throw new Error(
+        `Failed to get rows: ${response.status} ${response.statusText} ${JSON.stringify({
+          app,
+          table,
+        })}`
+      );
     }
 
     const [result] = await response.json();
@@ -189,7 +224,38 @@ class Table<T extends ColumnSchema> {
 }
 
 class App {
-  constructor(private props: AppProps) {}
+  private props: AppProps;
+  private client: Client;
+
+  public get id() {
+    return this.props.id;
+  }
+
+  public get name() {
+    return this.props.name;
+  }
+
+  constructor(props: AppProps) {
+    this.props = { ...props, token: props.token ?? process.env.GLIDE_TOKEN! };
+    this.client = makeClient({
+      token: process.env.GLIDE_TOKEN!,
+    });
+  }
+
+  public async getTableNamed(name: string) {
+    const tables = await this.getTables();
+    return tables?.find(t => t.name === name);
+  }
+
+  public async getTables() {
+    const { id } = this.props;
+    const result = await this.client.get(`/apps/${id}/tables`);
+
+    if (result.status !== 200) return undefined;
+
+    const { data: tables }: { data: IDName[] } = await result.json();
+    return tables.map(t => this.table({ table: t.id, name: t.name, columns: {} }));
+  }
 
   public table<T extends ColumnSchema>(props: Omit<TableProps<T>, "app">) {
     return new Table<T>({
@@ -201,10 +267,29 @@ class App {
   }
 }
 
-export function app(props: AppProps): App {
+export function app(props: AppProps | string): App {
+  if (typeof props === "string") {
+    props = { id: props };
+  }
   return new App(props);
 }
 
+export async function getApps(props: { token?: string } = {}): Promise<App[] | undefined> {
+  const client = makeClient(props);
+  const response = await client.get(`/apps`);
+  if (response.status !== 200) return undefined;
+  const { data: apps }: { data: IDName[] } = await response.json();
+  return apps.map(idName => app({ ...props, ...idName }));
+}
+
+export async function getAppNamed(
+  name: string,
+  props: { token?: string } = {}
+): Promise<App | undefined> {
+  const apps = await getApps(props);
+  return apps?.find(a => a.name === name);
+}
+
 export function table<T extends ColumnSchema>(props: TableProps<T>) {
   return new Table<T>(props);
 }

src/rest.ts

@@ -0,0 +1,20 @@
+import fetch from "cross-fetch";
+
+export function makeClient({ token = process.env.GLIDE_TOKEN! }: { token?: string } = {}) {
+  return {
+    get(route: string, r: RequestInit = {}) {
+      return fetch(`https://functions.prod.internal.glideapps.com/api${route}`, {
+        method: "GET",
+        ...r,
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/json",
+          Accept: "application/json",
+          ...r.headers,
+        },
+      });
+    },
+  };
+}
+
+export type Client = ReturnType<typeof makeClient>;

src/table.test.ts

@@ -1,9 +1,13 @@
+require("dotenv").config();
+
 import * as glide from ".";
 import type { RowOf } from ".";
 
+const token = process.env.GLIDE_TOKEN!;
+
 const app = glide.app({
   id: "bAFxpGXU1bHiBgUMcDgn",
-  token: process.env.GLIDE_TOKEN,
+  token,
 });
 
 const inventory = app.table({
@@ -25,6 +29,30 @@ const inventoryStaging = glide.table({
   },
 });
 
+describe("app", () => {
+  it("can get apps", async () => {
+    const apps = await glide.getApps();
+    expect(apps).toBeDefined();
+    expect(apps?.length).toBeGreaterThan(0);
+  });
+
+  it("can get an app by name", async () => {
+    const app = await glide.getAppNamed("API Testing");
+    expect(app).toBeDefined();
+  });
+
+  it("can get tables", async () => {
+    const tables = await app.getTables();
+    expect(tables).toBeDefined();
+    expect(tables?.length).toBeGreaterThan(0);
+  });
+
+  it("can get a table by name", async () => {
+    const table = await app.getTableNamed("Inv - Inventory");
+    expect(table).toBeDefined();
+  });
+});
+
 describe("table", () => {
   jest.setTimeout(60_000);
 
@@ -101,4 +129,11 @@ describe("table", () => {
     const renamed = await inventory.getRow(rowID);
     expect(renamed?.Item).toBe("Renamed");
   });
+
+  it("can get schema", async () => {
+    const {
+      data: { columns },
+    } = await inventory.getSchema();
+    expect(columns).toBeTruthy();
+  });
 });

src/types.ts

@@ -47,9 +47,10 @@ export type FullRow<T extends ColumnSchema> = Pretty<
   } & Row<T>
 >;
 
-export interface TableProps<T> {
+export interface TableProps<T = {}> {
   token?: string;
   endpoint?: string;
+  name?: string;
 
   app: string;
   table: string;
@@ -60,4 +61,5 @@ export interface AppProps {
   id: string;
   token?: string;
   endpoint?: string;
+  name?: string;
 }