@htlkg/data 0.0.1 → 0.0.3

package/src/queries/users.ts

@@ -0,0 +1,199 @@
+/**
+ * User Query Functions
+ *
+ * Provides query functions for fetching user data from the GraphQL API.
+ */
+
+import type { User } from "@htlkg/core/types";
+
+/**
+ * Get a single user by ID
+ *
+ * @example
+ * ```typescript
+ * import { getUser } from '@htlkg/data/queries';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * const user = await getUser(client, 'user-123');
+ * ```
+ */
+export async function getUser<TClient = any>(
+	client: TClient,
+	id: string,
+): Promise<User | null> {
+	try {
+		const { data, errors } = await (client as any).models.User.get({ id });
+
+		if (errors) {
+			console.error("[getUser] GraphQL errors:", errors);
+			return null;
+		}
+
+		return data as User;
+	} catch (error) {
+		console.error("[getUser] Error fetching user:", error);
+		throw error;
+	}
+}
+
+/**
+ * Get a user by Cognito ID
+ *
+ * @example
+ * ```typescript
+ * import { getUserByCognitoId } from '@htlkg/data/queries';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * const user = await getUserByCognitoId(client, 'cognito-id-123');
+ * ```
+ */
+export async function getUserByCognitoId<TClient = any>(
+	client: TClient,
+	cognitoId: string,
+): Promise<User | null> {
+	try {
+		const { data, errors } = await (client as any).models.User.list({
+			filter: { cognitoId: { eq: cognitoId } },
+			limit: 1,
+		});
+
+		if (errors) {
+			console.error("[getUserByCognitoId] GraphQL errors:", errors);
+			return null;
+		}
+
+		return data?.[0] as User | null;
+	} catch (error) {
+		console.error("[getUserByCognitoId] Error fetching user:", error);
+		throw error;
+	}
+}
+
+/**
+ * Get a user by email
+ *
+ * @example
+ * ```typescript
+ * import { getUserByEmail } from '@htlkg/data/queries';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * const user = await getUserByEmail(client, 'user@example.com');
+ * ```
+ */
+export async function getUserByEmail<TClient = any>(
+	client: TClient,
+	email: string,
+): Promise<User | null> {
+	try {
+		const { data, errors } = await (client as any).models.User.list({
+			filter: { email: { eq: email } },
+			limit: 1,
+		});
+
+		if (errors) {
+			console.error("[getUserByEmail] GraphQL errors:", errors);
+			return null;
+		}
+
+		return data?.[0] as User | null;
+	} catch (error) {
+		console.error("[getUserByEmail] Error fetching user:", error);
+		throw error;
+	}
+}
+
+/**
+ * List all users with optional filtering
+ *
+ * @example
+ * ```typescript
+ * import { listUsers } from '@htlkg/data/queries';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * const users = await listUsers(client, {
+ *   filter: { status: { eq: 'active' } }
+ * });
+ * ```
+ */
+export async function listUsers<TClient = any>(
+	client: TClient,
+	options?: {
+		filter?: any;
+		limit?: number;
+		nextToken?: string;
+	},
+): Promise<{ items: User[]; nextToken?: string }> {
+	try {
+		const { data, errors, nextToken } = await (client as any).models.User.list(
+			options,
+		);
+
+		if (errors) {
+			console.error("[listUsers] GraphQL errors:", errors);
+			return { items: [], nextToken: undefined };
+		}
+
+		return {
+			items: (data || []) as User[],
+			nextToken,
+		};
+	} catch (error) {
+		console.error("[listUsers] Error fetching users:", error);
+		throw error;
+	}
+}
+
+/**
+ * List users by account ID
+ *
+ * @example
+ * ```typescript
+ * import { listUsersByAccount } from '@htlkg/data/queries';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * const users = await listUsersByAccount(client, 'account-123');
+ * ```
+ */
+export async function listUsersByAccount<TClient = any>(
+	client: TClient,
+	accountId: string,
+	options?: {
+		limit?: number;
+		nextToken?: string;
+	},
+): Promise<{ items: User[]; nextToken?: string }> {
+	return listUsers(client, {
+		filter: { accountId: { eq: accountId } },
+		...options,
+	});
+}
+
+/**
+ * List active users
+ *
+ * @example
+ * ```typescript
+ * import { listActiveUsers } from '@htlkg/data/queries';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * const users = await listActiveUsers(client);
+ * ```
+ */
+export async function listActiveUsers<TClient = any>(
+	client: TClient,
+	options?: {
+		limit?: number;
+		nextToken?: string;
+	},
+): Promise<{ items: User[]; nextToken?: string }> {
+	return listUsers(client, {
+		filter: { status: { eq: "active" } },
+		...options,
+	});
+}

package/src/stores/createStores.ts

@@ -0,0 +1,148 @@
+/**
+ * Store Factory
+ *
+ * Creates request-scoped nanostores for sharing data across Vue islands
+ * without props. Works with @inox-tools/request-nanostores for Astro integration.
+ */
+
+import { atom, type WritableAtom } from "nanostores";
+
+/**
+ * Type for the shared function from @it-astro:request-nanostores
+ */
+type SharedFn = <T>(key: string, atomFactory: WritableAtom<T>) => WritableAtom<T>;
+
+/**
+ * Configuration for a resource store
+ */
+export interface StoreConfig {
+	/** Resource name (e.g., 'accounts', 'users') */
+	name: string;
+	/** Related resources to create stores for (e.g., ['brands', 'products']) */
+	relations?: string[];
+}
+
+/**
+ * Result type for created stores
+ */
+export type ResourceStores<T, TRelations extends string = never> = {
+	/** Main resource store */
+	$data: WritableAtom<readonly T[]>;
+} & {
+	[K in TRelations as `$${K}`]: WritableAtom<readonly any[]>;
+};
+
+/**
+ * Capitalize first letter of a string
+ */
+function capitalize(str: string): string {
+	return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+/**
+ * Creates request-scoped stores for a resource and its relations.
+ *
+ * This factory is designed to work with Astro's request-nanostores integration,
+ * providing request-isolated state that syncs from server to client.
+ *
+ * @param shared - The shared function from @it-astro:request-nanostores
+ * @param config - Store configuration
+ * @returns Object containing the main store and relation stores
+ *
+ * @example
+ * ```typescript
+ * // In your store file (e.g., stores/accounts.ts)
+ * import { shared } from '@it-astro:request-nanostores';
+ * import { createResourceStores } from '@htlkg/data/stores';
+ *
+ * export const accountStores = createResourceStores(shared, {
+ *   name: 'accounts',
+ *   relations: ['brands'],
+ * });
+ *
+ * // This creates:
+ * // - accountStores.$data (WritableAtom<any[]>) - main accounts store
+ * // - accountStores.$brands (WritableAtom<any[]>) - related brands store
+ *
+ * // For cleaner exports:
+ * export const $accounts = accountStores.$data;
+ * export const $accountsBrands = accountStores.$brands;
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With typed stores
+ * interface Account { id: number; name: string; }
+ * interface Brand { id: number; name: string; }
+ *
+ * export const { $data: $accounts, $brands } = createResourceStores<Account, 'brands'>(
+ *   shared,
+ *   { name: 'accounts', relations: ['brands'] }
+ * );
+ * ```
+ */
+export function createResourceStores<T = any, TRelations extends string = never>(
+	shared: SharedFn,
+	config: StoreConfig & { relations?: TRelations[] },
+): ResourceStores<T, TRelations> {
+	const { name, relations = [] } = config;
+
+	const stores: Record<string, any> = {};
+
+	// Main resource store
+	stores.$data = shared(name, atom<T[]>([]));
+
+	// Relation stores
+	for (const relation of relations) {
+		const storeKey = `$${relation}`;
+		const sharedKey = `${name}${capitalize(relation)}`;
+		stores[storeKey] = shared(sharedKey, atom<any[]>([]));
+	}
+
+	return stores as ResourceStores<T, TRelations>;
+}
+
+/**
+ * Creates a simple single store (non-factory version for simpler use cases)
+ *
+ * @example
+ * ```typescript
+ * import { shared } from '@it-astro:request-nanostores';
+ * import { createStore } from '@htlkg/data/stores';
+ *
+ * export const $currentUser = createStore<User>(shared, 'currentUser');
+ * ```
+ */
+export function createStore<T>(
+	shared: SharedFn,
+	name: string,
+	defaultValue: T[] = [],
+): WritableAtom<readonly T[]> {
+	return shared(name, atom<T[]>(defaultValue));
+}
+
+/**
+ * Creates a single-value store (for non-array values like current user)
+ *
+ * @example
+ * ```typescript
+ * import { shared } from '@it-astro:request-nanostores';
+ * import { createSingleStore } from '@htlkg/data/stores';
+ *
+ * export const $currentUser = createSingleStore<User | null>(shared, 'currentUser', null);
+ * ```
+ */
+export function createSingleStore<T>(
+	shared: SharedFn,
+	name: string,
+	defaultValue: T,
+): WritableAtom<T> {
+	return shared(name, atom<T>(defaultValue));
+}
+
+/**
+ * Helper to create typed store with proper inference
+ */
+export type InferStoreType<TStore extends WritableAtom<any>> = TStore extends WritableAtom<infer T>
+	? T
+	: never;

package/src/stores/index.ts

@@ -0,0 +1,15 @@
+/**
+ * Store Factories for @htlkg/data
+ *
+ * Utilities for creating request-scoped nanostores that work with Astro's
+ * server-client state synchronization.
+ */
+
+export {
+	createResourceStores,
+	createStore,
+	createSingleStore,
+	type StoreConfig,
+	type ResourceStores,
+	type InferStoreType,
+} from "./createStores";

package/src/stores/stores.md

@@ -0,0 +1,104 @@
+# Stores Module
+
+Nanostore factories for request-scoped state management in Astro SSR.
+
+## Installation
+
+```typescript
+import { 
+  createResourceStores,
+  createStore,
+  createSingleStore,
+} from '@htlkg/data/stores';
+```
+
+## createResourceStores
+
+Create a set of stores for a resource type with list and single-item stores.
+
+```typescript
+import { createResourceStores } from '@htlkg/data/stores';
+import type { Brand } from '@htlkg/core/types';
+
+const brandStores = createResourceStores<Brand>('brands');
+
+// List store
+brandStores.list.set([brand1, brand2]);
+const brands = brandStores.list.get();
+
+// Single item store
+brandStores.current.set(selectedBrand);
+const current = brandStores.current.get();
+
+// Loading state
+brandStores.loading.set(true);
+```
+
+## createStore
+
+Create a simple list store.
+
+```typescript
+import { createStore } from '@htlkg/data/stores';
+
+const accountsStore = createStore<Account[]>('accounts', []);
+
+accountsStore.set(accounts);
+const value = accountsStore.get();
+```
+
+## createSingleStore
+
+Create a store for a single item (nullable).
+
+```typescript
+import { createSingleStore } from '@htlkg/data/stores';
+
+const currentUserStore = createSingleStore<User>('currentUser');
+
+currentUserStore.set(user);
+const user = currentUserStore.get(); // User | null
+```
+
+## Astro SSR Integration
+
+Stores work with Astro's server-client state sync:
+
+```astro
+---
+// Server-side: populate store
+import { brandStores } from '@/stores';
+import { fetchBrands } from '@htlkg/data/queries';
+
+const brands = await fetchBrands(client, { accountId });
+brandStores.list.set(brands);
+---
+
+<BrandList client:load />
+```
+
+```vue
+<!-- Client-side: read from store -->
+<script setup>
+import { useStore } from '@nanostores/vue';
+import { brandStores } from '@/stores';
+
+const brands = useStore(brandStores.list);
+</script>
+```
+
+## Types
+
+```typescript
+interface StoreConfig<T> {
+  name: string;
+  initial?: T;
+}
+
+interface ResourceStores<T> {
+  list: WritableAtom<T[]>;
+  current: WritableAtom<T | null>;
+  loading: WritableAtom<boolean>;
+  error: WritableAtom<Error | null>;
+}
+```