@agnocon/piece-bika 0.1.7

package/src/lib/actions/find-records.ts

@@ -0,0 +1,62 @@
+import {
+  PiecePropValueSchema,
+  Property,
+  createAction,
+} from '@agnocon/pieces-framework';
+import { BikaCommon, makeClient } from '../common';
+import { BikaAuth } from '../auth';
+import { prepareQuery } from '../common/client';
+
+export const findRecordsAction = createAction({
+  auth: BikaAuth,
+  name: 'bika_find_records',
+  displayName: 'Find Records',
+  description: 'Finds records in database.',
+  audience: 'both',
+  aiMetadata: { description: 'Lists records from a Bika.ai database, optionally narrowed by a filter expression (Bika filter-query-language); with no filter it returns all records up to the configured limits. Use to search or page through a table when you need multiple matching rows rather than a single known ID. Read-only and idempotent.', idempotent: true },
+  props: {
+    space_id: BikaCommon.space_id,
+    database_id: BikaCommon.database_id,
+    maxRecords: Property.Number({
+      displayName: 'Max Records',
+      description: 'How many records are returned in total.',
+      required: false,
+    }),
+    pageSize: Property.Number({
+      displayName: 'Page Size',
+      description: 'How many records are returned per page (max 1000).',
+      required: false,
+    }),
+    filter: Property.LongText({
+      displayName: 'Filter',
+      description:
+        'The filter to apply to the records (see https://bika.ai/help/guide/developer/filter-query-language).',
+      required: false,
+    }),
+  },
+  async run(context) {
+    const databaseId = context.propsValue.database_id;
+    const spaceId = context.propsValue.space_id;
+    const maxRecords = context.propsValue.maxRecords;
+    const pageSize = context.propsValue.pageSize ?? 100;
+    const filter = context.propsValue.filter;
+
+    const client = makeClient(
+      context.auth.props,
+    );
+    const response: any = await client.listRecords(
+      spaceId,
+      databaseId,
+      prepareQuery({
+        pageSize,
+        maxRecords,
+        filter,
+      })
+    );
+
+    if (!response.success) {
+      throw new Error(JSON.stringify(response, undefined, 2));
+    }
+    return response;
+  },
+});

package/src/lib/actions/update-record.ts

@@ -0,0 +1,65 @@
+import {
+	DynamicPropsValue,
+	PiecePropValueSchema,
+	Property,
+	createAction,
+} from '@agnocon/pieces-framework';
+import { BikaCommon, createNewFields, makeClient } from '../common';
+import { BikaAuth } from '../auth';
+
+export const updateRecordAction = createAction({
+	auth: BikaAuth,
+	name: 'bika_update_record',
+	displayName: 'Update Record',
+	description: 'Updates an existing record in database.',
+	audience: 'both',
+	aiMetadata: { description: 'Updates the fields of an existing Bika.ai record identified by its record ID, within a given space and database. Use when modifying a known record; provide only the fields to change (read-only field types are ignored). Idempotent: repeating with the same input leaves the record in the same state.', idempotent: true },
+	props: {
+		space_id: BikaCommon.space_id,
+		database_id: BikaCommon.database_id,
+		recordId: Property.ShortText({
+			displayName: 'Record ID',
+			description: 'The ID of the record to update.',
+			required: true,
+		}),
+		fields: BikaCommon.fields,
+	},
+	async run(context) {
+		const auth = context.auth;
+		const databaseId = context.propsValue.database_id;
+		const spaceId = context.propsValue.space_id;
+		const recordId = context.propsValue.recordId;
+		const dynamicFields: DynamicPropsValue = context.propsValue.fields;
+		const fields: {
+			[n: string]: any;
+		} = {};
+
+		const props = Object.entries(dynamicFields);
+		for (const [propertyKey, propertyValue] of props) {
+			if (propertyValue !== undefined && propertyValue !== '') {
+				fields[propertyKey] = propertyValue;
+			}
+		}
+
+		const newFields: Record<string, unknown> = await createNewFields(
+			auth,
+			spaceId,
+			databaseId,
+			fields,
+		);
+
+		const client = makeClient(context.auth.props);
+
+		const response: any = await client.updateRecord(spaceId, databaseId, recordId, {
+					fields: {
+						...newFields,
+					},
+		});
+
+		if (!response.success) {
+			throw new Error(JSON.stringify(response, undefined, 2));
+		}
+
+		return response;
+	},
+});

package/src/lib/auth.ts

@@ -0,0 +1,40 @@
+import { PieceAuth, PiecePropValueSchema } from '@agnocon/pieces-framework';
+import { makeClient } from './common';
+
+export const BikaAuth = PieceAuth.CustomAuth({
+  required: true,
+  description: `
+    To obtain your Bika token, follow these steps:
+
+    1. Log in to your Bika account.
+    2. Visit https://bika.com.
+    3. Click on your profile picture (Bottom left).
+    4. Click on "My Settings".
+    5. Click on "Developer".
+    6. Click on "Generate new token".
+    7. Copy the token.
+    `,
+  props: {
+    token: PieceAuth.SecretText({
+      displayName: 'Token',
+      description: 'The token of the Bika account',
+      required: true,
+    }),
+  },
+  validate: async ({ auth }) => {
+    try {
+      const client = makeClient(
+        auth as PiecePropValueSchema<typeof BikaAuth>
+      );
+      await client.listSpaces();
+      return {
+        valid: true,
+      };
+    } catch (e) {
+      return {
+        valid: false,
+        error: 'Invalid Token.',
+      };
+    }
+  },
+});

package/src/lib/common/client.ts

@@ -0,0 +1,147 @@
+import {
+  HttpMessageBody,
+  HttpMethod,
+  QueryParams,
+  AuthenticationType,
+  httpClient,
+} from '@agnocon/pieces-common';
+import { BikaFieldType } from './constants';
+
+function emptyValueFilter(
+  accessor: (key: string) => any
+): (key: string) => boolean {
+  return (key: string) => {
+    const val = accessor(key);
+    return (
+      val !== null &&
+      val !== undefined &&
+      (typeof val != 'string' || val.length > 0)
+    );
+  };
+}
+
+export function prepareQuery(request?: Record<string, any>): QueryParams {
+  const params: QueryParams = {};
+  if (!request) return params;
+  Object.keys(request)
+    .filter(emptyValueFilter((k) => request[k]))
+    .forEach((k: string) => {
+      params[k] = (request as Record<string, any>)[k].toString();
+    });
+  return params;
+}
+
+
+export class BikaClient {
+  constructor( private token: string, private bikaUrl = "https://bika.ai") {}
+
+  async makeRequest<T extends HttpMessageBody>(
+    method: HttpMethod,
+    resourceUri: string,
+    query?: QueryParams,
+    body: any | undefined = undefined
+  ): Promise<T> {
+    const baseUrl = this.bikaUrl.replace(/\/$/, '');
+
+    const res = await httpClient.sendRequest<T>({
+      method: method,
+      url: `${baseUrl}/api/openapi/bika` + resourceUri,
+      authentication: {
+        type: AuthenticationType.BEARER_TOKEN,
+        token: this.token,
+      },
+      queryParams: query,
+      body: body,
+    });
+
+    return res.body;
+  }
+
+  async listSpaces() {
+    return await this.makeRequest<{
+      data: {
+          id: string;
+          name: string;
+        }[];
+    }>(HttpMethod.GET, '/v1/spaces');
+  }
+  async listDatabases(space_id: string) {
+    return await this.makeRequest<{
+      data: {
+          id: string;
+          name: string;
+      }[];
+    }>(HttpMethod.GET, `/v1/spaces/${space_id}/nodes`);
+  }
+
+  async getDatabaseFields(space_id: string, database_id: string) {
+    return await this.makeRequest<{
+      data: {
+          id: string;
+          name: string;
+          type: BikaFieldType;
+          desc: string;
+          property?: {
+            format?: string;
+            defaultValue?: string;
+            options?: {
+              name: string;
+              id?: string;
+            }[];
+        };
+      }[];
+    }>(HttpMethod.GET, `/v1/spaces/${space_id}/resources/databases/${database_id}/fields`);
+  }
+
+  async createRecord(space_id: string, database_id: string, request: object) {
+    return await this.makeRequest(
+      HttpMethod.POST,
+      `/v2/spaces/${space_id}/resources/databases/${database_id}/records`,
+      undefined,
+      request
+    );
+  }
+    async deleteRecord(space_id: string, database_id: string, record_id: string) {
+    return await this.makeRequest(
+      HttpMethod.DELETE,
+      `/v2/spaces/${space_id}/resources/databases/${database_id}/records/${record_id}`
+    );
+  }
+  async updateRecord(space_id: string, database_id: string, record_id: string, request: object) {
+    return await this.makeRequest(
+      HttpMethod.PUT,
+      `/v2/spaces/${space_id}/resources/databases/${database_id}/records/${record_id}`,
+      undefined,
+      request
+    );
+  }
+
+    async findRecord(space_id: string, database_id: string, record_id: string, query?: QueryParams) {
+    return await this.makeRequest<{
+      data: {
+        total: number;
+        records: {
+          recordId: string;
+          createdAt: number;
+          updatedAt: number;
+          fields: Record<string, unknown>;
+        }[];
+      };
+    }>(HttpMethod.GET, `/v2/spaces/${space_id}/resources/databases/${database_id}/records/${record_id}`, query);
+  }
+
+
+  async listRecords(space_id: string, database_id: string, query?: QueryParams) {
+    return await this.makeRequest<{
+      data: {
+        total: number;
+        records: {
+          recordId: string;
+          createdAt: number;
+          updatedAt: number;
+          fields: Record<string, unknown>;
+        }[];
+      };
+    }>(HttpMethod.GET, `/v2/spaces/${space_id}/resources/databases/${database_id}/records`, query);
+  }
+}

package/src/lib/common/constants.ts

@@ -0,0 +1,33 @@
+export const enum BikaFieldType {
+	SINGLE_TEXT = 'SINGLE_TEXT',
+	LINK = 'LINK',
+	LOOKUP = 'LOOKUP',
+	SINGLE_SELECT = 'SINGLE_SELECT',
+	MEMBER = 'MEMBER',
+	DATETIME = 'DATETIME',
+	NUMBER = 'NUMBER',
+	FORMULA = 'FORMULA',
+	LONG_TEXT = 'LONG_TEXT',
+	MULTI_SELECT = 'MULTI_SELECT',
+	CURRENCY = 'CURRENCY',
+	PERCENT = 'PERCENT',
+	RATING = 'RATING',
+	CHECKBOX = 'CHECKBOX',
+	URL = 'URL',
+	PHONE = 'PHONE',
+	EMAIL = 'EMAIL',
+	AUTONUMBER = 'AUTONUMBER',
+	CREATED_BY = 'CREATED_BY',
+	LAST_MODIFIED_BY = 'LAST_MODIFIED_BY',
+	CASCADER = 'CASCADER',
+	CREATED_TIME = 'CREATED_TIME',
+	LAST_MODIFIED_TIME = 'LAST_MODIFIED_TIME',
+	ATTACHMENT = 'ATTACHMENT',
+}
+
+export const BikaNumericFieldTypes = [
+	BikaFieldType.NUMBER,
+	BikaFieldType.RATING,
+	BikaFieldType.CURRENCY,
+	BikaFieldType.PERCENT,
+];

package/src/lib/common/index.ts

@@ -0,0 +1,250 @@
+import { AppConnectionValueForAuthProperty, DynamicPropsValue, PiecePropValueSchema, Property } from '@agnocon/pieces-framework';
+import { BikaAuth } from '../auth';
+import { BikaClient } from './client';
+import { BikaFieldType, BikaNumericFieldTypes } from './constants';
+
+export function makeClient(auth: PiecePropValueSchema<typeof BikaAuth>) {
+	const client = new BikaClient(auth.token);
+	return client;
+}
+
+export const BikaCommon = {
+	space_id: Property.Dropdown({
+		auth: BikaAuth,
+		displayName: 'Space',
+		required: true,
+		refreshers: [],
+		options: async ({ auth }) => {
+			if (!auth) {
+				return {
+					disabled: true,
+					options: [],
+					placeholder: 'Connect your account first.',
+				};
+			}
+			const client = makeClient(auth.props);
+			const res = await client.listSpaces();
+			return {
+				disabled: false,
+				options: res.data.map((space) => {
+					return {
+						label: space.name,
+						value: space.id,
+					};
+				}),
+			};
+		},
+	}),
+	database_id: Property.Dropdown({
+		auth: BikaAuth,
+		displayName: 'Database',
+		required: true,
+		refreshers: ['space_id'],
+		options: async ({ auth, space_id }) => {
+			if (!auth || !space_id) {
+				return {
+					disabled: true,
+					options: [],
+					placeholder: 'Connect your account first and select space.',
+				};
+			}
+			const client = makeClient(auth.props);
+			const res = await client.listDatabases(space_id as string);
+
+			return {
+				disabled: false,
+				options: res.data.map((database) => {
+					return {
+						label: database.name,
+						value: database.id,
+					};
+				}),
+			};
+		},
+	}),
+	fields: Property.DynamicProperties({
+		auth: BikaAuth,
+		displayName: 'Fields',
+		description: 'The fields to add to the record.',
+		required: true,
+		refreshers: ['auth', 'space_id', 'database_id'],
+		props: async ({ auth, space_id, database_id }) => {
+			if(!auth || !space_id || !database_id) return {};
+			
+			const client = makeClient(auth.props);
+			const res = await client.getDatabaseFields(space_id as unknown as  string, database_id as unknown as string);
+
+			const props: DynamicPropsValue = {};
+
+			for (const field of res.data) {
+				if (
+					![
+						BikaFieldType.AUTONUMBER,
+						BikaFieldType.CASCADER,
+						BikaFieldType.CREATED_BY,
+						BikaFieldType.CREATED_TIME,
+						BikaFieldType.FORMULA,
+						BikaFieldType.LAST_MODIFIED_BY,
+						BikaFieldType.LAST_MODIFIED_TIME,
+						BikaFieldType.LOOKUP,
+					].includes(field.type)
+				) {
+					switch (field.type) {
+						case BikaFieldType.ATTACHMENT:
+							props[field.name] = Property.File({
+								displayName: field.name,
+								required: false,
+							});
+							break;
+						case BikaFieldType.CHECKBOX:
+							props[field.name] = Property.Checkbox({
+								displayName: field.name,
+								required: false,
+							});
+							break;
+						case BikaFieldType.CURRENCY:
+						case BikaFieldType.NUMBER:
+						case BikaFieldType.PERCENT:
+						case BikaFieldType.RATING:
+							props[field.name] = Property.Number({
+								displayName: field.name,
+								required: false,
+							});
+							break;
+						case BikaFieldType.DATETIME:
+							props[field.name] = Property.DateTime({
+								displayName: field.name,
+								required: false,
+							});
+							break;
+						case BikaFieldType.EMAIL:
+						case BikaFieldType.PHONE:
+						case BikaFieldType.SINGLE_TEXT:
+						case BikaFieldType.URL:
+							props[field.name] = Property.ShortText({
+								displayName: field.name,
+								required: false,
+							});
+							break;
+						case BikaFieldType.LONG_TEXT:
+							props[field.name] = Property.LongText({
+								displayName: field.name,
+								required: false,
+							});
+							break;
+						case BikaFieldType.MULTI_SELECT:
+							props[field.name] = Property.StaticMultiSelectDropdown({
+								displayName: field.name,
+								required: false,
+								options: {
+									options: field.property?.options?.map((option) => ({
+										label: option.name,
+										value: option.name,
+									})) || [],
+								},
+							});
+							break;
+						case BikaFieldType.SINGLE_SELECT:
+							props[field.name] = Property.StaticDropdown({
+								displayName: field.name,
+								required: false,
+								options: {
+									options: field.property?.options?.map((option) => ({
+										label: option.name,
+										value: option.name,
+									})) || [],
+								},
+							});
+							break;
+						case BikaFieldType.MEMBER:
+							props[field.name] = Property.StaticMultiSelectDropdown({
+								displayName: field.name,
+								required: false,
+								options: {
+									options:
+										field.property?.options?.map((option) => {
+											return {
+												label: option.name,
+												value: option.id,
+											};
+										}) || [],
+								},
+							});
+							break;
+					case BikaFieldType.LINK:
+							props[field.name] = Property.Array({
+								displayName: field.name,
+								required: false,
+							});
+							break;
+					}
+				}
+			}
+			return props;
+		},
+	}),
+};
+
+export async function createNewFields(
+	auth: AppConnectionValueForAuthProperty<typeof BikaAuth>,
+	space_id: string,
+	database_id: string,
+	fields: Record<string, unknown>,
+) {
+	if (!auth) return fields;
+	if (!database_id) return fields;
+
+	const newFields: Record<string, unknown> = {};
+
+	const client = makeClient(auth.props);
+	const res = await client.getDatabaseFields(space_id,database_id);
+
+	for(const field of res.data) {
+		if (
+			[
+			  BikaFieldType.AUTONUMBER,
+			  BikaFieldType.CASCADER,
+			  BikaFieldType.CREATED_BY,
+			  BikaFieldType.CREATED_TIME,
+			  BikaFieldType.FORMULA,
+			  BikaFieldType.LAST_MODIFIED_TIME,
+			  BikaFieldType.LAST_MODIFIED_BY,
+			  BikaFieldType.LOOKUP,
+			].includes(field.type) || !(field.name in fields)
+		  ) {
+			continue; // Skip irrelevant or missing fields
+		  }
+
+		  const key = field.name;
+
+		  // Handle numeric fields
+		  if(BikaNumericFieldTypes.includes(field.type))
+		  {
+			newFields[key] = Number(fields[key]);
+		  }
+		  // Handle member fields
+		  else if(field.type === BikaFieldType.MEMBER)
+		  {
+			newFields[key] = field.property?.options?.filter(
+				(member) => member.id === `${fields[key]}`,
+			);
+		  }
+		  // Handle multi-select and two-way-link fields
+		  else if([BikaFieldType.MULTI_SELECT].includes(field.type))
+		  {
+			if(!Array.isArray(fields[key]) || (fields[key] as Array<unknown>).length === 0)
+			{
+				continue; // Skip empty fields
+			}
+			newFields[key] = fields[key];
+		  }
+		  // Handle all other fields
+		  else
+		  {
+			newFields[key] = fields[key];
+		}
+
+
+	}
+	return newFields;
+}