@htlkg/data 0.0.1 → 0.0.3

package/src/mutations/accounts.ts

@@ -0,0 +1,127 @@
+/**
+ * Account Mutation Functions
+ *
+ * Provides mutation functions for creating, updating, and deleting accounts.
+ */
+
+import type { Account } from "@htlkg/core/types";
+
+/**
+ * Input type for creating an account
+ */
+export interface CreateAccountInput {
+	name: string;
+	logo?: string;
+	subscription?: Record<string, any>;
+	settings?: Record<string, any>;
+}
+
+/**
+ * Input type for updating an account
+ */
+export interface UpdateAccountInput {
+	id: string;
+	name?: string;
+	logo?: string;
+	subscription?: Record<string, any>;
+	settings?: Record<string, any>;
+}
+
+/**
+ * Create a new account
+ *
+ * @example
+ * ```typescript
+ * import { createAccount } from '@htlkg/data/mutations';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * const account = await createAccount(client, {
+ *   name: 'My Account',
+ *   subscription: { plan: 'premium' }
+ * });
+ * ```
+ */
+export async function createAccount<TClient = any>(
+	client: TClient,
+	input: CreateAccountInput,
+): Promise<Account | null> {
+	try {
+		const { data, errors } = await (client as any).models.Account.create(input);
+
+		if (errors) {
+			console.error("[createAccount] GraphQL errors:", errors);
+			return null;
+		}
+
+		return data as Account;
+	} catch (error) {
+		console.error("[createAccount] Error creating account:", error);
+		throw error;
+	}
+}
+
+/**
+ * Update an existing account
+ *
+ * @example
+ * ```typescript
+ * import { updateAccount } from '@htlkg/data/mutations';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * const account = await updateAccount(client, {
+ *   id: 'account-123',
+ *   name: 'Updated Account Name'
+ * });
+ * ```
+ */
+export async function updateAccount<TClient = any>(
+	client: TClient,
+	input: UpdateAccountInput,
+): Promise<Account | null> {
+	try {
+		const { data, errors } = await (client as any).models.Account.update(input);
+
+		if (errors) {
+			console.error("[updateAccount] GraphQL errors:", errors);
+			return null;
+		}
+
+		return data as Account;
+	} catch (error) {
+		console.error("[updateAccount] Error updating account:", error);
+		throw error;
+	}
+}
+
+/**
+ * Delete an account
+ *
+ * @example
+ * ```typescript
+ * import { deleteAccount } from '@htlkg/data/mutations';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * await deleteAccount(client, 'account-123');
+ * ```
+ */
+export async function deleteAccount<TClient = any>(
+	client: TClient,
+	id: string,
+): Promise<boolean> {
+	try {
+		const { errors } = await (client as any).models.Account.delete({ id });
+
+		if (errors) {
+			console.error("[deleteAccount] GraphQL errors:", errors);
+			return false;
+		}
+
+		return true;
+	} catch (error) {
+		console.error("[deleteAccount] Error deleting account:", error);
+		throw error;
+	}
+}

package/src/mutations/brands.ts

@@ -0,0 +1,133 @@
+/**
+ * Brand Mutation Functions
+ *
+ * Provides mutation functions for creating, updating, and deleting brands.
+ */
+
+import type { Brand } from "@htlkg/core/types";
+
+/**
+ * Input type for creating a brand
+ */
+export interface CreateBrandInput {
+	accountId: string;
+	name: string;
+	logo?: string;
+	timezone?: string;
+	status?: "active" | "inactive" | "maintenance" | "suspended";
+	settings?: Record<string, any>;
+}
+
+/**
+ * Input type for updating a brand
+ */
+export interface UpdateBrandInput {
+	id: string;
+	name?: string;
+	logo?: string;
+	timezone?: string;
+	status?: "active" | "inactive" | "maintenance" | "suspended";
+	settings?: Record<string, any>;
+}
+
+/**
+ * Create a new brand
+ *
+ * @example
+ * ```typescript
+ * import { createBrand } from '@htlkg/data/mutations';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * const brand = await createBrand(client, {
+ *   accountId: 'account-123',
+ *   name: 'My Brand',
+ *   timezone: 'America/New_York',
+ *   status: 'active'
+ * });
+ * ```
+ */
+export async function createBrand<TClient = any>(
+	client: TClient,
+	input: CreateBrandInput,
+): Promise<Brand | null> {
+	try {
+		const { data, errors } = await (client as any).models.Brand.create(input);
+
+		if (errors) {
+			console.error("[createBrand] GraphQL errors:", errors);
+			return null;
+		}
+
+		return data as Brand;
+	} catch (error) {
+		console.error("[createBrand] Error creating brand:", error);
+		throw error;
+	}
+}
+
+/**
+ * Update an existing brand
+ *
+ * @example
+ * ```typescript
+ * import { updateBrand } from '@htlkg/data/mutations';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * const brand = await updateBrand(client, {
+ *   id: 'brand-123',
+ *   name: 'Updated Brand Name',
+ *   status: 'maintenance'
+ * });
+ * ```
+ */
+export async function updateBrand<TClient = any>(
+	client: TClient,
+	input: UpdateBrandInput,
+): Promise<Brand | null> {
+	try {
+		const { data, errors } = await (client as any).models.Brand.update(input);
+
+		if (errors) {
+			console.error("[updateBrand] GraphQL errors:", errors);
+			return null;
+		}
+
+		return data as Brand;
+	} catch (error) {
+		console.error("[updateBrand] Error updating brand:", error);
+		throw error;
+	}
+}
+
+/**
+ * Delete a brand
+ *
+ * @example
+ * ```typescript
+ * import { deleteBrand } from '@htlkg/data/mutations';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * await deleteBrand(client, 'brand-123');
+ * ```
+ */
+export async function deleteBrand<TClient = any>(
+	client: TClient,
+	id: string,
+): Promise<boolean> {
+	try {
+		const { errors } = await (client as any).models.Brand.delete({ id });
+
+		if (errors) {
+			console.error("[deleteBrand] GraphQL errors:", errors);
+			return false;
+		}
+
+		return true;
+	} catch (error) {
+		console.error("[deleteBrand] Error deleting brand:", error);
+		throw error;
+	}
+}

package/src/mutations/index.ts

@@ -0,0 +1,32 @@
+/**
+ * Mutation Functions for @htlkg/data
+ *
+ * Provides mutation functions for creating, updating, and deleting data via the GraphQL API.
+ */
+
+// Brand mutations
+export {
+	createBrand,
+	updateBrand,
+	deleteBrand,
+	type CreateBrandInput,
+	type UpdateBrandInput,
+} from "./brands";
+
+// Account mutations
+export {
+	createAccount,
+	updateAccount,
+	deleteAccount,
+	type CreateAccountInput,
+	type UpdateAccountInput,
+} from "./accounts";
+
+// User mutations
+export {
+	createUser,
+	updateUser,
+	deleteUser,
+	type CreateUserInput,
+	type UpdateUserInput,
+} from "./users";

package/src/mutations/mutations.md

@@ -0,0 +1,96 @@
+# Mutations Module
+
+GraphQL mutation functions for creating, updating, and deleting resources.
+
+## Installation
+
+```typescript
+import { 
+  createAccount,
+  updateAccount,
+  deleteAccount,
+  createBrand,
+  updateBrand,
+  deleteBrand,
+  createUser,
+  updateUser,
+  deleteUser,
+} from '@htlkg/data/mutations';
+```
+
+## Account Mutations
+
+```typescript
+// Create
+const account = await createAccount(client, {
+  name: 'New Account',
+  settings: {},
+});
+
+// Update
+const updated = await updateAccount(client, {
+  id: 'account-123',
+  name: 'Updated Name',
+});
+
+// Delete
+await deleteAccount(client, { id: 'account-123' });
+```
+
+## Brand Mutations
+
+```typescript
+// Create
+const brand = await createBrand(client, {
+  name: 'New Brand',
+  accountId: 'account-123',
+  timezone: 'Europe/Madrid',
+  status: 'active',
+});
+
+// Update
+const updated = await updateBrand(client, {
+  id: 'brand-456',
+  name: 'Updated Brand',
+  status: 'inactive',
+});
+
+// Delete
+await deleteBrand(client, { id: 'brand-456' });
+```
+
+## User Mutations
+
+```typescript
+// Create
+const user = await createUser(client, {
+  email: 'user@example.com',
+  accountId: 'account-123',
+  status: 'active',
+});
+
+// Update
+const updated = await updateUser(client, {
+  id: 'user-789',
+  status: 'inactive',
+});
+
+// Delete
+await deleteUser(client, { id: 'user-789' });
+```
+
+## Error Handling
+
+```typescript
+try {
+  const brand = await createBrand(client, data);
+} catch (error) {
+  if (error.errors) {
+    // GraphQL errors
+    console.error('Validation errors:', error.errors);
+  } else {
+    // Network or other errors
+    console.error('Mutation failed:', error.message);
+  }
+}
+```

package/src/mutations/users.ts

@@ -0,0 +1,136 @@
+/**
+ * User Mutation Functions
+ *
+ * Provides mutation functions for creating, updating, and deleting users.
+ */
+
+import type { User } from "@htlkg/core/types";
+
+/**
+ * Input type for creating a user
+ */
+export interface CreateUserInput {
+	cognitoId: string;
+	email: string;
+	accountId: string;
+	brandIds?: string[];
+	roles?: string[];
+	permissions?: Record<string, any>;
+	status?: "active" | "inactive" | "pending" | "suspended";
+}
+
+/**
+ * Input type for updating a user
+ */
+export interface UpdateUserInput {
+	id: string;
+	email?: string;
+	brandIds?: string[];
+	roles?: string[];
+	permissions?: Record<string, any>;
+	lastLogin?: string;
+	status?: "active" | "inactive" | "pending" | "suspended";
+}
+
+/**
+ * Create a new user
+ *
+ * @example
+ * ```typescript
+ * import { createUser } from '@htlkg/data/mutations';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * const user = await createUser(client, {
+ *   cognitoId: 'cognito-123',
+ *   email: 'user@example.com',
+ *   accountId: 'account-123',
+ *   roles: ['BRAND_ADMIN'],
+ *   status: 'active'
+ * });
+ * ```
+ */
+export async function createUser<TClient = any>(
+	client: TClient,
+	input: CreateUserInput,
+): Promise<User | null> {
+	try {
+		const { data, errors } = await (client as any).models.User.create(input);
+
+		if (errors) {
+			console.error("[createUser] GraphQL errors:", errors);
+			return null;
+		}
+
+		return data as User;
+	} catch (error) {
+		console.error("[createUser] Error creating user:", error);
+		throw error;
+	}
+}
+
+/**
+ * Update an existing user
+ *
+ * @example
+ * ```typescript
+ * import { updateUser } from '@htlkg/data/mutations';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * const user = await updateUser(client, {
+ *   id: 'user-123',
+ *   roles: ['BRAND_ADMIN', 'ACCOUNT_ADMIN'],
+ *   status: 'active'
+ * });
+ * ```
+ */
+export async function updateUser<TClient = any>(
+	client: TClient,
+	input: UpdateUserInput,
+): Promise<User | null> {
+	try {
+		const { data, errors } = await (client as any).models.User.update(input);
+
+		if (errors) {
+			console.error("[updateUser] GraphQL errors:", errors);
+			return null;
+		}
+
+		return data as User;
+	} catch (error) {
+		console.error("[updateUser] Error updating user:", error);
+		throw error;
+	}
+}
+
+/**
+ * Delete a user
+ *
+ * @example
+ * ```typescript
+ * import { deleteUser } from '@htlkg/data/mutations';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * await deleteUser(client, 'user-123');
+ * ```
+ */
+export async function deleteUser<TClient = any>(
+	client: TClient,
+	id: string,
+): Promise<boolean> {
+	try {
+		const { errors } = await (client as any).models.User.delete({ id });
+
+		if (errors) {
+			console.error("[deleteUser] GraphQL errors:", errors);
+			return false;
+		}
+
+		return true;
+	} catch (error) {
+		console.error("[deleteUser] Error deleting user:", error);
+		throw error;
+	}
+}

package/src/queries/accounts.ts

@@ -0,0 +1,121 @@
+/**
+ * Account Query Functions
+ *
+ * Provides query functions for fetching account data from the GraphQL API.
+ */
+
+import type { Account } from "@htlkg/core/types";
+
+/**
+ * Get a single account by ID
+ *
+ * @example
+ * ```typescript
+ * import { getAccount } from '@htlkg/data/queries';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * const account = await getAccount(client, 'account-123');
+ * ```
+ */
+export async function getAccount<TClient = any>(
+	client: TClient,
+	id: string,
+): Promise<Account | null> {
+	try {
+		const { data, errors } = await (client as any).models.Account.get({ id });
+
+		if (errors) {
+			console.error("[getAccount] GraphQL errors:", errors);
+			return null;
+		}
+
+		return data as Account;
+	} catch (error) {
+		console.error("[getAccount] Error fetching account:", error);
+		throw error;
+	}
+}
+
+/**
+ * List all accounts with optional filtering
+ *
+ * @example
+ * ```typescript
+ * import { listAccounts } from '@htlkg/data/queries';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * const accounts = await listAccounts(client);
+ * ```
+ */
+export async function listAccounts<TClient = any>(
+	client: TClient,
+	options?: {
+		filter?: any;
+		limit?: number;
+		nextToken?: string;
+	},
+): Promise<{ items: Account[]; nextToken?: string }> {
+	try {
+		const { data, errors, nextToken } = await (
+			client as any
+		).models.Account.list(options);
+
+		if (errors) {
+			console.error("[listAccounts] GraphQL errors:", errors);
+			return { items: [], nextToken: undefined };
+		}
+
+		return {
+			items: (data || []) as Account[],
+			nextToken,
+		};
+	} catch (error) {
+		console.error("[listAccounts] Error fetching accounts:", error);
+		throw error;
+	}
+}
+
+/**
+ * Get an account with its brands
+ *
+ * @example
+ * ```typescript
+ * import { getAccountWithBrands } from '@htlkg/data/queries';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * const account = await getAccountWithBrands(client, 'account-123');
+ * ```
+ */
+export async function getAccountWithBrands<TClient = any>(
+	client: TClient,
+	id: string,
+): Promise<Account | null> {
+	try {
+		const { data, errors } = await (client as any).models.Account.get(
+			{ id },
+			{
+				selectionSet: [
+					"id",
+					"name",
+					"logo",
+					"subscription",
+					"settings",
+					"brands.*",
+				],
+			},
+		);
+
+		if (errors) {
+			console.error("[getAccountWithBrands] GraphQL errors:", errors);
+			return null;
+		}
+
+		return data as Account;
+	} catch (error) {
+		console.error("[getAccountWithBrands] Error fetching account:", error);
+		throw error;
+	}
+}