@simpleapps-com/augur-api 0.1.0

package/dist/esm/services/joomla/client.js

@@ -0,0 +1,466 @@
+import { BaseServiceClient } from '../../core/base-client';
+import { ContentListParamsSchema, ContentListResponseSchema, ContentGetParamsSchema, ContentResponseSchema, DocumentResponseSchema, UserListParamsSchema, UserListResponseSchema, UserResponseSchema, UserGroupListParamsSchema, UserGroupListResponseSchema, UserGroupMembershipResponseSchema, UserGroupDetailResponseSchema, TagListParamsSchema, TagListResponseSchema, HealthCheckResponseSchema, VerifyPasswordRequestSchema, VerifyPasswordResponseSchema, TrinityDocParamsSchema, TrinityDocResponseSchema, CreateUserRequestSchema, CreateUserResponseSchema, UpdateUserRequestSchema, UpdateUserResponseSchema, BlockUserResponseSchema, UserGroupMappingRequestSchema, UserGroupMappingResponseSchema, } from './schemas';
+/**
+ * Joomla API Client
+ * @description Client for interacting with Joomla microservice API endpoints
+ * @example
+ * ```typescript
+ * import { HTTPClient } from '@augur/api-client/core';
+ * import { JoomlaClient } from '@augur/api-client/services/joomla';
+ *
+ * const http = new HTTPClient('joomla', { siteId: 'your-site-id', bearerToken: 'your-token' });
+ * const joomla = new JoomlaClient(http);
+ *
+ * // List content
+ * const content = await joomla.content.list({ limit: 10 });
+ *
+ * // Verify user password
+ * const auth = await joomla.users.verifyPassword({ username: 'user', password: 'pass' });
+ * ```
+ */
+export class JoomlaClient extends BaseServiceClient {
+    /**
+     * Create a new JoomlaClient instance
+     * @param http Configured HTTPClient instance
+     * @param baseUrl Base URL for the Joomla API (default: https://joomla.augur-api.com)
+     */
+    constructor(http, baseUrl = 'https://joomla.augur-api.com') {
+        super('joomla', http, baseUrl);
+        /**
+         * Content endpoints
+         * @description Methods for content management including articles, documents, and metadata
+         */
+        this.content = {
+            /**
+             * Retrieve a paginated list of content items
+             * @description Returns all content with optional filtering, pagination, and edge caching
+             * @param params Optional filtering, pagination, and caching parameters
+             * @param params.edgeCache Optional cache duration in hours (1, 2, 3, 4, 5, 8)
+             * @returns Array of content items
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * // Get all content
+             * const content = await client.content.list();
+             *
+             * // Get filtered content
+             * const filtered = await client.content.list({
+             *   categoryIdList: '1,2,3',
+             *   limit: 20,
+             *   q: 'search term'
+             * });
+             *
+             * // Get content with 4-hour edge caching
+             * const cached = await client.content.list({
+             *   edgeCache: 4,  // Cache for 4 hours
+             *   categoryIdList: '1,2,3',
+             *   limit: 20
+             * });
+             * ```
+             */
+            list: this.createListMethod('/content', ContentListParamsSchema, ContentListResponseSchema),
+            /**
+             * Get content details by ID
+             * @description Returns a single content item by its ID or alias with optional edge caching
+             * @param contentId Content ID (number) or alias lookup (use 0 with params.alias)
+             * @param params Optional parameters for alias lookup and caching
+             * @param params.edgeCache Optional cache duration in hours (1, 2, 3, 4, 5, 8)
+             * @returns Content item details
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * // Get by ID
+             * const content = await client.content.get(123);
+             *
+             * // Get by alias
+             * const content = await client.content.get(0, { alias: 'my-article', catid: 45 });
+             *
+             * // Get with 8-hour edge caching
+             * const cachedContent = await client.content.get(123, { edgeCache: 8 });
+             * ```
+             */
+            get: async (contentId, params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/content/{id}',
+                    paramsSchema: ContentGetParamsSchema,
+                    responseSchema: ContentResponseSchema,
+                }, params, { id: String(contentId) });
+            },
+            /**
+             * Get content documentation
+             * @description Returns enhanced content document with custom fields, images, and metadata
+             * @param contentId Content ID (number) or alias lookup (use 0 with query params)
+             * @returns Enhanced content document with additional metadata
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const doc = await client.content.getDoc(123);
+             * console.log(doc.id, doc.title, doc.content, doc.metadata);
+             * ```
+             */
+            getDoc: this.createDocMethod('/content/{id}/doc', DocumentResponseSchema),
+        };
+        /**
+         * User endpoints
+         * @description Methods for user management including authentication, CRUD operations, and group management
+         */
+        this.users = {
+            /**
+             * Retrieve a paginated list of users
+             * @description Returns all users with optional filtering, pagination, and edge caching
+             * @param params Optional filtering, pagination, and caching parameters
+             * @param params.edgeCache Optional cache duration in hours (1, 2, 3, 4, 5, 8)
+             * @returns Paginated user list with total count
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * // Get all users
+             * const users = await client.users.list();
+             * console.log(`Found ${users.total} users, showing ${users.data.length}`);
+             *
+             * // Search users
+             * const searchResults = await client.users.list({ q: 'admin', limit: 5 });
+             *
+             * // Get users with 2-hour edge caching
+             * const cachedUsers = await client.users.list({
+             *   edgeCache: 2,  // Cache for 2 hours
+             *   limit: 20
+             * });
+             * ```
+             */
+            list: this.createListMethod('/users', UserListParamsSchema, UserListResponseSchema),
+            /**
+             * Get user details by ID
+             * @description Returns detailed information for a specific user with optional edge caching
+             * @param userId User ID (number or string)
+             * @param params Optional caching parameters
+             * @param params.edgeCache Optional cache duration in hours (1, 2, 3, 4, 5, 8)
+             * @returns User details including profile information
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const user = await client.users.get(123);
+             * console.log(user.username, user.email, user.registerDate);
+             *
+             * // Get with 1-hour edge caching
+             * const cachedUser = await client.users.get(123, { edgeCache: 1 });
+             * ```
+             */
+            get: this.createGetMethod('/users/{id}', UserResponseSchema),
+            /**
+             * Get user documentation
+             * @description Returns enhanced user document with profile values, customer information, and metadata
+             * @param userId User ID (number or string)
+             * @returns Enhanced user document with profile data
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const userDoc = await client.users.getDoc(123);
+             * console.log(userDoc.id, userDoc.title, userDoc.content);
+             * ```
+             */
+            getDoc: async (userId) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/users/{id}/doc',
+                    responseSchema: DocumentResponseSchema,
+                }, undefined, { id: String(userId) });
+            },
+            /**
+             * Get Trinity user documentation
+             * @description Returns specialized Trinity business logic document with territory assignment and role detection
+             * @param userId User ID (number or string)
+             * @param params Optional filtering and pagination parameters
+             * @returns Trinity document with profile, role, groups, and territory information
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * const trinity = await client.users.getTrinityDoc(123);
+             * console.log(trinity.profile.companyName, trinity.territory, trinity.role);
+             *
+             * // With filtering
+             * const filtered = await client.users.getTrinityDoc(123, { q: 'search', limit: 5 });
+             * ```
+             */
+            getTrinityDoc: async (userId, params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/users/{id}/trinity',
+                    paramsSchema: TrinityDocParamsSchema,
+                    responseSchema: TrinityDocResponseSchema,
+                }, params, { id: String(userId) });
+            },
+            /**
+             * User groups sub-endpoints
+             * @description Methods for managing user group memberships and relationships
+             */
+            groups: {
+                /**
+                 * Get user's groups
+                 * @description Returns all groups that a specific user belongs to
+                 * @param userId User ID (string)
+                 * @param params Optional pagination parameters
+                 * @returns Array of user group memberships
+                 * @throws ValidationError When response is malformed
+                 * @example
+                 * ```typescript
+                 * const groups = await client.users.groups.list('123');
+                 * groups.forEach(group => console.log(group.title, group.groupId));
+                 * ```
+                 */
+                list: async (userId, params) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/users/{id}/groups',
+                        responseSchema: UserGroupMembershipResponseSchema,
+                    }, params, { id: userId });
+                },
+                /**
+                 * Get specific user group membership
+                 * @description Returns detailed information about a user's membership in a specific group
+                 * @param userId User ID (string)
+                 * @param groupId Group ID (number or string)
+                 * @returns User group membership details
+                 * @throws ValidationError When response is malformed
+                 * @example
+                 * ```typescript
+                 * const membership = await client.users.groups.get('123', 1);
+                 * console.log(membership.groupTitle, membership.memberSince);
+                 * ```
+                 */
+                get: async (userId, groupId) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/users/{userId}/groups/{groupId}',
+                        responseSchema: UserGroupDetailResponseSchema,
+                    }, undefined, { userId, groupId: String(groupId) });
+                },
+                /**
+                 * Create or update user group mapping
+                 * @description Adds or updates a user's membership in a group
+                 * @param userId User ID (number or string)
+                 * @param request Group mapping request data
+                 * @returns Created or updated group mapping information
+                 * @throws ValidationError When request is invalid or response is malformed
+                 * @example
+                 * ```typescript
+                 * const mapping = await client.users.groups.createMapping(123, { groupId: 5 });
+                 * console.log(mapping.created ? 'Created' : 'Updated', 'group mapping');
+                 * ```
+                 */
+                createMapping: async (userId, request) => {
+                    return this.executeRequest({
+                        method: 'POST',
+                        path: '/users/{id}/groups',
+                        paramsSchema: UserGroupMappingRequestSchema,
+                        responseSchema: UserGroupMappingResponseSchema,
+                    }, request, { id: String(userId) });
+                },
+            },
+            /**
+             * Verify user password
+             * @description Verifies if the provided username and password are valid, supporting cross-site authentication
+             *
+             * Cross-site authentication:
+             * - When called from 'augur_info' site, can authenticate users from any other site
+             * - Include optional 'siteId' parameter to authenticate against a different site
+             * - Returned JWT token will be scoped to the target site, not augur_info
+             *
+             * @param request Object containing username, password, and optional siteId for cross-site auth
+             * @returns Object with verification status, user ID, username, token (if verified), and email
+             *
+             * @example
+             * // Standard authentication
+             * await client.users.verifyPassword({ username: 'user', password: 'pass' });
+             *
+             * // Cross-site authentication (when using augur_info as x-site-id header)
+             * await client.users.verifyPassword({
+             *   username: 'user',
+             *   password: 'pass',
+             *   siteId: 'customer_site_1'
+             * });
+             */
+            verifyPassword: async (request) => {
+                return this.executeRequest({
+                    method: 'POST',
+                    path: '/users/verify-password',
+                    paramsSchema: VerifyPasswordRequestSchema,
+                    responseSchema: VerifyPasswordResponseSchema,
+                }, request);
+            },
+            /**
+             * Create a new user
+             * @description Creates a new user account in the system
+             * @param request User creation request data including username, email, name, and password
+             * @returns Created user information with ID, username, and email
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const newUser = await client.users.create({
+             *   username: 'newuser',
+             *   email: 'user@example.com',
+             *   name: 'New User',
+             *   password: 'SecurePass123!'
+             * });
+             * console.log('Created user:', newUser.id, newUser.username);
+             * ```
+             */
+            create: this.createCreateMethod('/users', CreateUserRequestSchema, CreateUserResponseSchema),
+            /**
+             * Update an existing user
+             * @description Updates user information for an existing user account
+             * @param userId User ID (number or string)
+             * @param request User update data with optional fields to modify
+             * @returns Updated user object with all current information
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const updatedUser = await client.users.update(123, {
+             *   email: 'newemail@example.com',
+             *   name: 'Updated Name',
+             *   block: 0 // Unblock user
+             * });
+             * console.log('Updated user:', updatedUser.username, updatedUser.email);
+             * ```
+             */
+            update: this.createUpdateMethod('/users/{id}', UpdateUserRequestSchema, UpdateUserResponseSchema),
+            /**
+             * Block (deactivate) a user
+             * @description Blocks a user account without deleting it, preventing user access to the system
+             * @param userId User ID (number or string)
+             * @returns Boolean indicating successful blocking operation
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const blocked = await client.users.block(123);
+             * if (blocked) {
+             *   console.log('User has been successfully blocked');
+             * }
+             * ```
+             */
+            block: this.createDeleteMethod('/users/{id}', BlockUserResponseSchema),
+        };
+        /**
+         * User Groups endpoints
+         * @description Methods for managing system-wide user groups and their hierarchy
+         */
+        this.userGroups = {
+            /**
+             * Get user groups
+             * @description Returns hierarchical list of user groups with optional filtering, ordering, and edge caching
+             * @param params Optional filtering, ordering, and caching parameters
+             * @param params.edgeCache Optional cache duration in hours (1, 2, 3, 4, 5, 8)
+             * @returns Array of user groups with hierarchy information
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * // Get all user groups
+             * const groups = await client.userGroups.list();
+             *
+             * // Get filtered groups
+             * const filtered = await client.userGroups.list({
+             *   orderBy: 'title|DESC',
+             *   parentIdList: '1,2'
+             * });
+             *
+             * // Get groups with 8-hour edge caching (groups rarely change)
+             * const cachedGroups = await client.userGroups.list({
+             *   edgeCache: 8,  // Cache for 8 hours
+             *   orderBy: 'title|ASC'
+             * });
+             *
+             * groups.forEach(group => {
+             *   console.log(`${group.title} (Level: ${group.level})`);
+             * });
+             * ```
+             */
+            list: async (params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/usergroups',
+                    paramsSchema: UserGroupListParamsSchema,
+                    responseSchema: UserGroupListResponseSchema,
+                }, params);
+            },
+        };
+        /**
+         * Tags endpoints
+         * @description Methods for managing content tags and their hierarchical relationships
+         */
+        this.tags = {
+            /**
+             * Get tags
+             * @description Returns hierarchical list of content tags with optional filtering, search, and edge caching
+             * @param params Optional filtering, search, and caching parameters
+             * @param params.edgeCache Optional cache duration in hours (1, 2, 3, 4, 5, 8)
+             * @returns Array of tags with hierarchy and usage information
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * // Get all tags
+             * const tags = await client.tags.list();
+             *
+             * // Search tags
+             * const searchTags = await client.tags.list({
+             *   q: 'technology',
+             *   catId: 1,
+             *   limit: 10
+             * });
+             *
+             * // Get tags with 5-hour edge caching (reference data)
+             * const cachedTags = await client.tags.list({
+             *   edgeCache: 5,  // Cache for 5 hours
+             *   limit: 50
+             * });
+             *
+             * tags.forEach(tag => {
+             *   console.log(`${tag.title} (${tag.hits} hits)`);
+             * });
+             * ```
+             */
+            list: this.createListMethod('/tags', TagListParamsSchema, TagListResponseSchema),
+        };
+        /**
+         * Menu endpoints
+         * @description Methods for accessing menu structure and navigation documentation
+         */
+        this.menu = {
+            /**
+             * Get menu documentation
+             * @description Returns enhanced menu item document with navigation hierarchy information
+             * @param menuId Menu item ID (string)
+             * @returns Complete menu document with navigation structure
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const menuDoc = await client.menu.getDoc('101');
+             * console.log('Menu:', menuDoc.data.title, menuDoc.data.link);
+             * console.log('Level:', menuDoc.data.level, 'Parent:', menuDoc.data.parentId);
+             * ```
+             */
+            getDoc: async (menuId) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/menu/{id}/doc',
+                    responseSchema: DocumentResponseSchema,
+                }, undefined, { id: menuId });
+            },
+        };
+        /**
+         * Check service health (no bearer token required)
+         * @description Monitor service availability without authentication overhead
+         * @returns Health check response with site information
+         * @throws ValidationError When response is malformed
+         * @example
+         * ```typescript
+         * const health = await client.getHealthCheck();
+         * console.log('Service health:', health.status);
+         * console.log('Site ID:', health.data.siteId);
+         * console.log('Site Hash:', health.data.siteHash);
+         * ```
+         */
+        this.getHealthCheck = this.createHealthCheckMethod(HealthCheckResponseSchema);
+    }
+}
+//# sourceMappingURL=client.js.map

package/dist/esm/services/joomla/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../../../../src/services/joomla/client.ts"],"names":[],"mappings":"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"}

package/dist/esm/services/joomla/index.d.ts

@@ -0,0 +1,3 @@
+export { JoomlaClient } from './client';
+export * from './schemas';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/services/joomla/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/services/joomla/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,cAAc,WAAW,CAAC"}

package/dist/esm/services/joomla/index.js

@@ -0,0 +1,3 @@
+export { JoomlaClient } from './client';
+export * from './schemas';
+//# sourceMappingURL=index.js.map

package/dist/esm/services/joomla/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/services/joomla/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,cAAc,WAAW,CAAC"}