semanticpen
Version:
AI Article Writer & SEO Blog Generator SDK - Professional TypeScript/JavaScript library for automated content creation, AI-powered article generation, and SEO blog writing with SemanticPen
205 lines • 6.89 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.ArticleService = void 0;
const BaseClient_1 = require("../core/BaseClient");
const errors_1 = require("../errors");
class ArticleService extends BaseClient_1.BaseClient {
async testConnection() {
try {
await this.get('/api/articles/00000000-0000-0000-0000-000000000000');
return true;
}
catch (error) {
if (error.statusCode === 404) {
return true;
}
if (error.statusCode === 401 || error.statusCode === 403) {
return false;
}
return false;
}
}
async generateArticles(request) {
this.validateGenerationRequest(request);
try {
const response = await this.post('/api/articles', request);
if (response.error) {
throw new Error(response.error);
}
return response;
}
catch (error) {
throw error;
}
}
async generateArticle(targetKeyword, options) {
const request = {
targetKeyword,
...options
};
const response = await this.generateArticles(request);
let articleId;
if (response.articleId) {
articleId = response.articleId;
}
else if (response.articleIds && response.articleIds.length > 0) {
articleId = response.articleIds[0];
}
else {
throw new Error('No articles were generated');
}
return {
articleId,
projectId: response.projectId,
message: response.message
};
}
async generateBulkArticles(keywords, options) {
if (!keywords || keywords.length === 0) {
throw new errors_1.ValidationError('Keywords array cannot be empty');
}
const successful = [];
const failed = [];
try {
const request = {
targetKeyword: keywords,
...options
};
const response = await this.generateArticles(request);
response.articleIds.forEach((articleId, index) => {
successful.push({
articleId,
keyword: keywords[index] || `keyword_${index}`
});
});
}
catch (error) {
keywords.forEach(keyword => {
failed.push({
item: keyword,
error: error.message || 'Generation failed'
});
});
}
return {
successful,
failed,
total: keywords.length,
successCount: successful.length,
failureCount: failed.length
};
}
async getArticle(articleId) {
if (!articleId || typeof articleId !== 'string') {
throw new errors_1.ValidationError('Article ID is required and must be a string');
}
try {
const article = await this.get(`/api/articles/${articleId}`);
return article;
}
catch (error) {
throw error;
}
}
async getArticles(articleIds) {
if (!articleIds || articleIds.length === 0) {
throw new errors_1.ValidationError('Article IDs array cannot be empty');
}
const successful = [];
const failed = [];
const promises = articleIds.map(async (articleId) => {
try {
const article = await this.getArticle(articleId);
return { success: true, article, articleId };
}
catch (error) {
return {
success: false,
error: error.message || 'Failed to retrieve article',
articleId
};
}
});
const results = await Promise.all(promises);
results.forEach(result => {
if (result.success) {
successful.push(result.article);
}
else {
failed.push({
item: result.articleId,
error: result.error
});
}
});
return {
successful,
failed,
total: articleIds.length,
successCount: successful.length,
failureCount: failed.length
};
}
async isArticleComplete(articleId) {
try {
const article = await this.getArticle(articleId);
return !!(article.article_html || article.content) &&
article.status !== 'queued' &&
article.status !== 'processing';
}
catch (error) {
if (error.statusCode === 404) {
return false;
}
throw error;
}
}
async getArticleStatus(articleId) {
try {
const article = await this.getArticle(articleId);
return {
id: article.id,
status: article.status,
isComplete: this.isStatusComplete(article.status),
hasError: article.status === 'failed',
errorMessage: article.error_message
};
}
catch (error) {
return {
id: articleId,
status: 'unknown',
isComplete: false,
hasError: true,
errorMessage: error.message || 'Failed to get status'
};
}
}
validateGenerationRequest(request) {
if (!request.targetKeyword) {
throw new errors_1.ValidationError('Target keyword is required');
}
if (typeof request.targetKeyword === 'string') {
if (request.targetKeyword.trim().length === 0) {
throw new errors_1.ValidationError('Target keyword cannot be empty');
}
}
else if (Array.isArray(request.targetKeyword)) {
if (request.targetKeyword.length === 0) {
throw new errors_1.ValidationError('Target keywords array cannot be empty');
}
const invalidKeywords = request.targetKeyword.filter(keyword => !keyword || typeof keyword !== 'string' || keyword.trim().length === 0);
if (invalidKeywords.length > 0) {
throw new errors_1.ValidationError('All keywords must be non-empty strings');
}
}
else {
throw new errors_1.ValidationError('Target keyword must be a string or array of strings');
}
}
isStatusComplete(status) {
return ['finished', 'failed'].includes(status.toLowerCase());
}
}
exports.ArticleService = ArticleService;
//# sourceMappingURL=ArticleService.js.map