@simpleapps-com/augur-api/dist/esm/core/schema-factories.js

TypeScript client library for Augur microservices API endpoints

import { z } from 'zod';
import { BaseResponseSchema } from './schemas';
import { StandardPaginationParamsSchema, EdgeCacheParamsSchema } from './common-schemas';
/**
 * Schema factory utilities for creating consistent, reusable schema patterns
 * across all microservices. These factories reduce duplication and ensure
 * standardization of common API patterns.
 */
/**
 * Create a standardized list parameters schema with pagination, search, and caching
 *
 * @param extensions Additional service-specific parameters to merge
 * @returns Combined schema with standard list parameters plus service extensions
 */
export const createListParamsSchema = (extensions) => {
    const baseSchema = StandardPaginationParamsSchema.merge(EdgeCacheParamsSchema).extend({
        q: z.string().optional(), // Universal search parameter
    });
    return extensions ? baseSchema.extend(extensions) : baseSchema;
};
/**
 * Create a standardized get parameters schema with caching support
 *
 * @param extensions Additional service-specific parameters to merge
 * @returns Combined schema with caching parameters plus service extensions
 */
export const createGetParamsSchema = (extensions) => {
    const baseSchema = EdgeCacheParamsSchema;
    return extensions ? baseSchema.extend(extensions) : baseSchema;
};
/**
 * Create a standardized list response schema
 *
 * @param itemSchema Schema for individual items in the list
 * @returns Response schema wrapping an array of items with pagination metadata
 */
export const createListResponseSchema = (itemSchema) => {
    return BaseResponseSchema(z.array(itemSchema));
};
/**
 * Create a standardized single item response schema
 *
 * @param itemSchema Schema for the individual item
 * @returns Response schema wrapping a single item
 */
export const createItemResponseSchema = (itemSchema) => {
    return BaseResponseSchema(itemSchema);
};
/**
 * Create a standardized document response schema for enhanced documentation endpoints
 * Common pattern for endpoints like /content/{id}/doc, /users/{id}/doc
 *
 * @param contentFields Additional fields beyond the standard document structure
 * @returns Schema for document responses with id, title, content, and optional extensions
 */
export const createDocumentResponseSchema = (contentFields) => {
    const baseDocumentSchema = z.object({
        id: z.string(),
        title: z.string(),
        content: z.string(),
        metadata: z.unknown().optional(),
    });
    const documentSchema = contentFields
        ? baseDocumentSchema.extend(contentFields)
        : baseDocumentSchema;
    return BaseResponseSchema(documentSchema);
};
/**
 * Create CRUD request schemas for a resource
 *
 * @param baseSchema The base schema for the resource (must be a ZodObject)
 * @returns Object containing create and update request schemas
 */
export const createCrudRequestSchemas = (baseSchema) => {
    return {
        create: baseSchema,
        update: baseSchema.partial(),
    };
};
/**
 * Create status-based schemas for resources with consistent status codes
 * Common pattern across services for status management
 *
 * @param statusValues Array of valid status code values
 * @returns Schema for status codes with proper constraints
 */
export const createStatusSchema = (statusValues) => {
    if (statusValues.length === 0) {
        throw new Error('Status values array cannot be empty');
    }
    if (statusValues.length === 1) {
        return z.literal(statusValues[0]);
    }
    const [first, second, ...rest] = statusValues.map(val => z.literal(val));
    return z.union([first, second, ...rest]);
};
/**
 * Create timestamp field schemas for resources with creation/modification tracking
 * Handles both camelCase and snake_case conventions
 *
 * @param useSnakeCase Whether to use snake_case (true) or camelCase (false) field names
 * @returns Schema object with timestamp fields
 */
export const createTimestampSchema = (useSnakeCase = false) => {
    if (useSnakeCase) {
        return z.object({
            date_created: z.string().optional(),
            date_last_modified: z.string().optional(),
        });
    }
    return z.object({
        dateCreated: z.string().optional(),
        dateLastModified: z.string().optional(),
    });
};
/**
 * Create a schema for CSV list parameters
 * Common pattern for parameters like categoryIdList, tagsList, etc.
 *
 * @param fieldName The name of the CSV field
 * @param description Optional description for the field
 * @returns Schema for CSV string parameters
 */
export const createCsvListSchema = (fieldName, description) => {
    return z.object({
        [fieldName]: z
            .string()
            .describe(description || `CSV list of ${fieldName.replace(/List$/, '')} values`),
    });
};
/**
 * Create ID field schemas with proper type constraints
 * Enforces the naming convention: *Uid = number, *Id = string
 *
 * @param fieldName The field name (should end with 'Uid' or 'Id')
 * @returns Appropriate schema based on naming convention
 */
export const createIdSchema = (fieldName) => {
    if (fieldName.endsWith('Uid')) {
        return z.number().int().positive().describe(`${fieldName} - Database UID (number)`);
    }
    if (fieldName.endsWith('Id')) {
        return z.string().min(1).describe(`${fieldName} - Identifier (string)`);
    }
    throw new Error(`ID field name '${fieldName}' must end with 'Uid' (for numbers) or 'Id' (for strings)`);
};
/**
 * Create a bulk response schema for operations that return multiple items
 *
 * @param itemSchema Schema for individual items
 * @param operationType Type of operation (create, update, delete)
 * @returns Response schema for bulk operations
 */
export const createBulkResponseSchema = (itemSchema, operationType) => {
    const responseData = operationType === 'delete'
        ? z.object({
            deletedCount: z.number(),
            deletedIds: z.array(z.union([z.string(), z.number()])),
        })
        : z.array(itemSchema);
    return BaseResponseSchema(responseData);
};
//# sourceMappingURL=schema-factories.js.map