pulse-ai-utils
Version:
Utility functions and helpers for AI-powered applications
222 lines • 8.46 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.contentTypesConfig = void 0;
exports.getEnabledContentTypes = getEnabledContentTypes;
exports.getContentTypeConfig = getContentTypeConfig;
exports.isContentTypeEnabled = isContentTypeEnabled;
exports.getDefaultContentTypes = getDefaultContentTypes;
exports.isUsedForSerp = isUsedForSerp;
exports.getDefaultContentType = getDefaultContentType;
exports.getPreferredContentType = getPreferredContentType;
exports.getSupabaseTypeForContentType = getSupabaseTypeForContentType;
exports.detectContentTypeFromData = detectContentTypeFromData;
const fs_1 = require("fs");
const path_1 = require("path");
const zod_1 = require("zod");
// Schema for content type configuration
const ContentTypeConfig = zod_1.z.object({
enabled: zod_1.z.boolean(),
schemaName: zod_1.z.string(),
isUsedForSerp: zod_1.z.boolean(),
supabaseType: zod_1.z.string().optional(),
detectionFields: zod_1.z.array(zod_1.z.string()).optional(),
comment: zod_1.z.string().optional()
});
const ContentTypesConfig = zod_1.z.object({
contentTypes: zod_1.z.record(ContentTypeConfig),
defaultContentTypes: zod_1.z.array(zod_1.z.string()),
futureTypes: zod_1.z.record(ContentTypeConfig).optional()
});
class ContentTypesConfigLoader {
constructor() {
this.config = null;
// Try multiple paths to find the config file
const possiblePaths = [
(0, path_1.join)(process.cwd(), 'configs', 'content-types.json'),
(0, path_1.join)(process.cwd(), '..', 'configs', 'content-types.json'),
(0, path_1.join)(__dirname, '..', '..', '..', 'configs', 'content-types.json'),
(0, path_1.join)(__dirname, '..', '..', '..', '..', 'configs', 'content-types.json')
];
for (const path of possiblePaths) {
try {
(0, fs_1.readFileSync)(path, 'utf8');
this.configPath = path;
break;
}
catch (e) {
// Continue to next path
}
}
if (!this.configPath) {
console.warn('Content types configuration file not found. Using defaults.');
this.configPath = '';
}
}
static getInstance() {
if (!ContentTypesConfigLoader.instance) {
ContentTypesConfigLoader.instance = new ContentTypesConfigLoader();
}
return ContentTypesConfigLoader.instance;
}
getConfig() {
if (!this.config) {
this.config = this.loadConfig();
}
return this.config;
}
loadConfig() {
if (!this.configPath) {
// Return default configuration if file not found
return this.getDefaultConfig();
}
try {
const rawConfig = (0, fs_1.readFileSync)(this.configPath, 'utf8');
const parsedConfig = JSON.parse(rawConfig);
return ContentTypesConfig.parse(parsedConfig);
}
catch (error) {
console.error('Error loading content types configuration:', error);
return this.getDefaultConfig();
}
}
getDefaultConfig() {
return {
contentTypes: {
events: {
enabled: true,
schemaName: 'EventSchema',
isUsedForSerp: false
},
deals: {
enabled: true,
schemaName: 'DealSchema',
isUsedForSerp: false
},
news: {
enabled: true,
schemaName: 'NewsArticleSchema',
isUsedForSerp: false
},
reels: {
enabled: true,
schemaName: 'ReelSchema',
isUsedForSerp: true,
comment: 'Reels use SERP API exclusively'
}
},
defaultContentTypes: ['events', 'deals', 'news', 'reels']
};
}
getEnabledContentTypes() {
const config = this.getConfig();
return Object.entries(config.contentTypes)
.filter(([_, typeConfig]) => typeConfig.enabled)
.map(([typeName, _]) => typeName);
}
getDefaultContentType() {
const config = this.getConfig();
const enabledTypes = this.getEnabledContentTypes();
// Use the first enabled type from the default list, or first enabled type
for (const defaultType of config.defaultContentTypes) {
if (enabledTypes.includes(defaultType)) {
return defaultType;
}
}
// Fallback to first enabled type if none of the defaults are enabled
if (enabledTypes.length > 0) {
return enabledTypes[0];
}
throw new Error('No enabled content types found');
}
getPreferredContentType(hint) {
if (hint) {
const enabledTypes = this.getEnabledContentTypes();
if (enabledTypes.includes(hint.toLowerCase())) {
return hint.toLowerCase();
}
}
return this.getDefaultContentType();
}
getSupabaseTypeForContentType(contentType) {
const config = this.getContentTypeConfig(contentType);
return config?.supabaseType || contentType;
}
detectContentTypeFromData(data) {
const config = this.getConfig();
const allTypes = { ...config.contentTypes, ...config.futureTypes };
// Check for explicit itemType field (used in Flyer items)
if (data.itemType) {
const normalized = data.itemType.toLowerCase().replace('_', '-');
// Map back to content type if it exists
for (const [typeName, typeConfig] of Object.entries(allTypes)) {
if (typeConfig.supabaseType === normalized || typeName === normalized) {
return typeName;
}
}
}
// Check enabled types first, then future types
for (const [typeName, typeConfig] of Object.entries(allTypes)) {
if (typeConfig.detectionFields && typeConfig.detectionFields.length > 0) {
const hasAllFields = typeConfig.detectionFields.every(field => data[field] !== undefined);
if (hasAllFields) {
return typeName;
}
}
}
return null;
}
getContentTypeConfig(typeName) {
const config = this.getConfig();
const typeConfig = config.contentTypes[typeName] || config.futureTypes?.[typeName];
return typeConfig || null;
}
isUsedForSerp(typeName) {
const typeConfig = this.getContentTypeConfig(typeName);
return typeConfig?.isUsedForSerp || false;
}
getSchemaNameForType(typeName) {
const typeConfig = this.getContentTypeConfig(typeName);
return typeConfig?.schemaName || null;
}
isTypeEnabled(typeName) {
const typeConfig = this.getContentTypeConfig(typeName);
return typeConfig?.enabled || false;
}
getDefaultContentTypes() {
return this.getConfig().defaultContentTypes;
}
reloadConfig() {
this.config = null;
}
}
// Export singleton instance
exports.contentTypesConfig = ContentTypesConfigLoader.getInstance();
// Export helper functions
function getEnabledContentTypes() {
return exports.contentTypesConfig.getEnabledContentTypes();
}
function getContentTypeConfig(typeName) {
return exports.contentTypesConfig.getContentTypeConfig(typeName);
}
function isContentTypeEnabled(typeName) {
return exports.contentTypesConfig.isTypeEnabled(typeName);
}
function getDefaultContentTypes() {
return exports.contentTypesConfig.getDefaultContentTypes();
}
function isUsedForSerp(typeName) {
return exports.contentTypesConfig.isUsedForSerp(typeName);
}
function getDefaultContentType() {
return exports.contentTypesConfig.getDefaultContentType();
}
function getPreferredContentType(hint) {
return exports.contentTypesConfig.getPreferredContentType(hint);
}
function getSupabaseTypeForContentType(contentType) {
return exports.contentTypesConfig.getSupabaseTypeForContentType(contentType);
}
function detectContentTypeFromData(data) {
return exports.contentTypesConfig.detectContentTypeFromData(data);
}
//# sourceMappingURL=content-types-config.js.map