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

TypeScript client library for Augur microservices API endpoints

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.createBulkResponseSchema = exports.createIdSchema = exports.createCsvListSchema = exports.createTimestampSchema = exports.createStatusSchema = exports.createCrudRequestSchemas = exports.createDocumentResponseSchema = exports.createItemResponseSchema = exports.createListResponseSchema = exports.createGetParamsSchema = exports.createListParamsSchema = void 0;
const zod_1 = require("zod");
const schemas_1 = require("./schemas");
const common_schemas_1 = require("./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
 */
const createListParamsSchema = (extensions) => {
    const baseSchema = common_schemas_1.StandardPaginationParamsSchema.merge(common_schemas_1.EdgeCacheParamsSchema).extend({
        q: zod_1.z.string().optional(), // Universal search parameter
    });
    return extensions ? baseSchema.extend(extensions) : baseSchema;
};
exports.createListParamsSchema = createListParamsSchema;
/**
 * 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
 */
const createGetParamsSchema = (extensions) => {
    const baseSchema = common_schemas_1.EdgeCacheParamsSchema;
    return extensions ? baseSchema.extend(extensions) : baseSchema;
};
exports.createGetParamsSchema = createGetParamsSchema;
/**
 * 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
 */
const createListResponseSchema = (itemSchema) => {
    return (0, schemas_1.BaseResponseSchema)(zod_1.z.array(itemSchema));
};
exports.createListResponseSchema = createListResponseSchema;
/**
 * Create a standardized single item response schema
 *
 * @param itemSchema Schema for the individual item
 * @returns Response schema wrapping a single item
 */
const createItemResponseSchema = (itemSchema) => {
    return (0, schemas_1.BaseResponseSchema)(itemSchema);
};
exports.createItemResponseSchema = createItemResponseSchema;
/**
 * 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
 */
const createDocumentResponseSchema = (contentFields) => {
    const baseDocumentSchema = zod_1.z.object({
        id: zod_1.z.string(),
        title: zod_1.z.string(),
        content: zod_1.z.string(),
        metadata: zod_1.z.unknown().optional(),
    });
    const documentSchema = contentFields
        ? baseDocumentSchema.extend(contentFields)
        : baseDocumentSchema;
    return (0, schemas_1.BaseResponseSchema)(documentSchema);
};
exports.createDocumentResponseSchema = createDocumentResponseSchema;
/**
 * 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
 */
const createCrudRequestSchemas = (baseSchema) => {
    return {
        create: baseSchema,
        update: baseSchema.partial(),
    };
};
exports.createCrudRequestSchemas = createCrudRequestSchemas;
/**
 * 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
 */
const createStatusSchema = (statusValues) => {
    if (statusValues.length === 0) {
        throw new Error('Status values array cannot be empty');
    }
    if (statusValues.length === 1) {
        return zod_1.z.literal(statusValues[0]);
    }
    const [first, second, ...rest] = statusValues.map(val => zod_1.z.literal(val));
    return zod_1.z.union([first, second, ...rest]);
};
exports.createStatusSchema = createStatusSchema;
/**
 * 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
 */
const createTimestampSchema = (useSnakeCase = false) => {
    if (useSnakeCase) {
        return zod_1.z.object({
            date_created: zod_1.z.string().optional(),
            date_last_modified: zod_1.z.string().optional(),
        });
    }
    return zod_1.z.object({
        dateCreated: zod_1.z.string().optional(),
        dateLastModified: zod_1.z.string().optional(),
    });
};
exports.createTimestampSchema = createTimestampSchema;
/**
 * 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
 */
const createCsvListSchema = (fieldName, description) => {
    return zod_1.z.object({
        [fieldName]: zod_1.z
            .string()
            .describe(description || `CSV list of ${fieldName.replace(/List$/, '')} values`),
    });
};
exports.createCsvListSchema = createCsvListSchema;
/**
 * 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
 */
const createIdSchema = (fieldName) => {
    if (fieldName.endsWith('Uid')) {
        return zod_1.z.number().int().positive().describe(`${fieldName} - Database UID (number)`);
    }
    if (fieldName.endsWith('Id')) {
        return zod_1.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)`);
};
exports.createIdSchema = createIdSchema;
/**
 * 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
 */
const createBulkResponseSchema = (itemSchema, operationType) => {
    const responseData = operationType === 'delete'
        ? zod_1.z.object({
            deletedCount: zod_1.z.number(),
            deletedIds: zod_1.z.array(zod_1.z.union([zod_1.z.string(), zod_1.z.number()])),
        })
        : zod_1.z.array(itemSchema);
    return (0, schemas_1.BaseResponseSchema)(responseData);
};
exports.createBulkResponseSchema = createBulkResponseSchema;
//# sourceMappingURL=schema-factories.js.map