@magicpages/ghost-typesense-core 0.0.0

package/dist/index.d.mts

@@ -0,0 +1,48 @@
+import { Config } from '@magicpages/ghost-typesense-config';
+
+interface Post {
+    id: string;
+    title: string;
+    slug: string;
+    html: string;
+    excerpt: string;
+    feature_image?: string;
+    published_at: number;
+    updated_at: number;
+    tags?: string[];
+    authors?: string[];
+    [key: string]: unknown;
+}
+declare class GhostTypesenseManager {
+    private ghost;
+    private typesense;
+    private config;
+    private collectionName;
+    constructor(config: Config);
+    /**
+     * Initialize the Typesense collection with the specified schema
+     */
+    initializeCollection(): Promise<void>;
+    /**
+     * Transform a Ghost post into the format expected by Typesense
+     */
+    private transformPost;
+    /**
+     * Fetch all posts from Ghost and index them in Typesense
+     */
+    indexAllPosts(): Promise<void>;
+    /**
+     * Index a single post in Typesense
+     */
+    indexPost(postId: string): Promise<void>;
+    /**
+     * Delete a post from Typesense
+     */
+    deletePost(postId: string): Promise<void>;
+    /**
+     * Clear all documents from the collection
+     */
+    clearCollection(): Promise<void>;
+}
+
+export { GhostTypesenseManager, type Post };

package/dist/index.d.ts

@@ -0,0 +1,48 @@
+import { Config } from '@magicpages/ghost-typesense-config';
+
+interface Post {
+    id: string;
+    title: string;
+    slug: string;
+    html: string;
+    excerpt: string;
+    feature_image?: string;
+    published_at: number;
+    updated_at: number;
+    tags?: string[];
+    authors?: string[];
+    [key: string]: unknown;
+}
+declare class GhostTypesenseManager {
+    private ghost;
+    private typesense;
+    private config;
+    private collectionName;
+    constructor(config: Config);
+    /**
+     * Initialize the Typesense collection with the specified schema
+     */
+    initializeCollection(): Promise<void>;
+    /**
+     * Transform a Ghost post into the format expected by Typesense
+     */
+    private transformPost;
+    /**
+     * Fetch all posts from Ghost and index them in Typesense
+     */
+    indexAllPosts(): Promise<void>;
+    /**
+     * Index a single post in Typesense
+     */
+    indexPost(postId: string): Promise<void>;
+    /**
+     * Delete a post from Typesense
+     */
+    deletePost(postId: string): Promise<void>;
+    /**
+     * Clear all documents from the collection
+     */
+    clearCollection(): Promise<void>;
+}
+
+export { GhostTypesenseManager, type Post };

package/dist/index.js

@@ -0,0 +1,183 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  GhostTypesenseManager: () => GhostTypesenseManager
+});
+module.exports = __toCommonJS(index_exports);
+var import_content_api = require("@ts-ghost/content-api");
+var import_typesense = require("typesense");
+var GhostTypesenseManager = class {
+  ghost;
+  typesense;
+  config;
+  collectionName;
+  constructor(config) {
+    this.config = config;
+    this.collectionName = config.collection.name;
+    this.ghost = new import_content_api.TSGhostContentAPI(
+      config.ghost.url,
+      config.ghost.key,
+      "v5.0"
+    );
+    this.typesense = new import_typesense.Client({
+      nodes: config.typesense.nodes,
+      apiKey: config.typesense.apiKey,
+      connectionTimeoutSeconds: config.typesense.connectionTimeoutSeconds,
+      retryIntervalSeconds: config.typesense.retryIntervalSeconds,
+      numRetries: 3
+    });
+  }
+  /**
+   * Initialize the Typesense collection with the specified schema
+   */
+  async initializeCollection() {
+    const collections = await this.typesense.collections().retrieve();
+    const existingCollection = collections.find((c) => c.name === this.collectionName);
+    if (existingCollection) {
+      const collection = this.typesense.collections(this.collectionName);
+      await collection.delete();
+    }
+    const schema = {
+      name: this.collectionName,
+      fields: this.config.collection.fields.map((field) => ({
+        name: field.name,
+        type: field.type,
+        facet: field.facet,
+        index: field.index,
+        optional: field.optional,
+        sort: field.sort
+      }))
+    };
+    await this.typesense.collections().create(schema);
+  }
+  /**
+   * Transform a Ghost post into the format expected by Typesense
+   */
+  transformPost(post) {
+    console.log("Transforming post:", post.id, post.title);
+    const transformed = {
+      id: post.id,
+      title: post.title,
+      slug: post.slug,
+      html: post.html,
+      excerpt: post.excerpt || "",
+      published_at: new Date(post.published_at || Date.now()).getTime(),
+      updated_at: new Date(post.updated_at || Date.now()).getTime()
+    };
+    if (post.feature_image) {
+      transformed.feature_image = post.feature_image;
+    }
+    const tags = post.tags;
+    if (tags && Array.isArray(tags) && tags.length > 0) {
+      transformed.tags = tags.map((tag) => tag.name);
+    }
+    const authors = post.authors;
+    if (authors && Array.isArray(authors) && authors.length > 0) {
+      transformed.authors = authors.map((author) => author.name);
+    }
+    this.config.collection.fields.forEach((field) => {
+      const value = post[field.name];
+      if (!transformed[field.name] && value !== void 0 && value !== null) {
+        transformed[field.name] = value;
+      }
+    });
+    console.log("Transformed document:", transformed);
+    return transformed;
+  }
+  /**
+   * Fetch all posts from Ghost and index them in Typesense
+   */
+  async indexAllPosts() {
+    let allPosts = [];
+    const posts = this.ghost.posts.browse({
+      limit: 15
+      // Default limit in Ghost
+    }).include({ tags: true, authors: true });
+    const response = await posts.fetch();
+    if (!response.success) {
+      throw new Error("Failed to fetch posts from Ghost");
+    }
+    allPosts = allPosts.concat(response.data);
+    const total = response.meta.pagination.total;
+    const limit = response.meta.pagination.limit;
+    const totalPages = Math.ceil(total / limit);
+    for (let page = 2; page <= totalPages; page++) {
+      const pageResponse = await this.ghost.posts.browse({
+        limit,
+        page
+      }).include({ tags: true, authors: true }).fetch();
+      if (!pageResponse.success) {
+        throw new Error(`Failed to fetch page ${page} from Ghost`);
+      }
+      allPosts = allPosts.concat(pageResponse.data);
+    }
+    console.log(`Found ${allPosts.length} posts to index`);
+    const documents = allPosts.map((post) => this.transformPost(post));
+    try {
+      const collection = this.typesense.collections(this.collectionName);
+      const results = await Promise.all(
+        documents.map(
+          (doc) => collection.documents().upsert(doc).then(() => ({ success: true, id: doc.id })).catch((error) => ({ success: false, id: doc.id, error: error.message }))
+        )
+      );
+      const succeeded = results.filter((r) => r.success).length;
+      const failed = results.filter((r) => !r.success).length;
+      console.log(`Indexing complete: ${succeeded} succeeded, ${failed} failed`);
+      if (failed > 0) {
+        console.log("Failed documents:", results.filter((r) => !r.success));
+      }
+    } catch (error) {
+      console.error("Indexing error:", error);
+      throw error;
+    }
+  }
+  /**
+   * Index a single post in Typesense
+   */
+  async indexPost(postId) {
+    const post = await this.ghost.posts.read({ id: postId }).include({ tags: true, authors: true }).fetch();
+    if (!post.success) {
+      throw new Error(`Failed to fetch post ${postId} from Ghost`);
+    }
+    const document = this.transformPost(post.data);
+    const collection = this.typesense.collections(this.collectionName);
+    await collection.documents().upsert(document);
+  }
+  /**
+   * Delete a post from Typesense
+   */
+  async deletePost(postId) {
+    const collection = this.typesense.collections(this.collectionName);
+    await collection.documents().delete({ filter_by: `id:${postId}` });
+  }
+  /**
+   * Clear all documents from the collection
+   */
+  async clearCollection() {
+    const collection = this.typesense.collections(this.collectionName);
+    await collection.documents().delete();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GhostTypesenseManager
+});

package/dist/index.mjs

@@ -0,0 +1,158 @@
+// src/index.ts
+import { TSGhostContentAPI } from "@ts-ghost/content-api";
+import { Client } from "typesense";
+var GhostTypesenseManager = class {
+  ghost;
+  typesense;
+  config;
+  collectionName;
+  constructor(config) {
+    this.config = config;
+    this.collectionName = config.collection.name;
+    this.ghost = new TSGhostContentAPI(
+      config.ghost.url,
+      config.ghost.key,
+      "v5.0"
+    );
+    this.typesense = new Client({
+      nodes: config.typesense.nodes,
+      apiKey: config.typesense.apiKey,
+      connectionTimeoutSeconds: config.typesense.connectionTimeoutSeconds,
+      retryIntervalSeconds: config.typesense.retryIntervalSeconds,
+      numRetries: 3
+    });
+  }
+  /**
+   * Initialize the Typesense collection with the specified schema
+   */
+  async initializeCollection() {
+    const collections = await this.typesense.collections().retrieve();
+    const existingCollection = collections.find((c) => c.name === this.collectionName);
+    if (existingCollection) {
+      const collection = this.typesense.collections(this.collectionName);
+      await collection.delete();
+    }
+    const schema = {
+      name: this.collectionName,
+      fields: this.config.collection.fields.map((field) => ({
+        name: field.name,
+        type: field.type,
+        facet: field.facet,
+        index: field.index,
+        optional: field.optional,
+        sort: field.sort
+      }))
+    };
+    await this.typesense.collections().create(schema);
+  }
+  /**
+   * Transform a Ghost post into the format expected by Typesense
+   */
+  transformPost(post) {
+    console.log("Transforming post:", post.id, post.title);
+    const transformed = {
+      id: post.id,
+      title: post.title,
+      slug: post.slug,
+      html: post.html,
+      excerpt: post.excerpt || "",
+      published_at: new Date(post.published_at || Date.now()).getTime(),
+      updated_at: new Date(post.updated_at || Date.now()).getTime()
+    };
+    if (post.feature_image) {
+      transformed.feature_image = post.feature_image;
+    }
+    const tags = post.tags;
+    if (tags && Array.isArray(tags) && tags.length > 0) {
+      transformed.tags = tags.map((tag) => tag.name);
+    }
+    const authors = post.authors;
+    if (authors && Array.isArray(authors) && authors.length > 0) {
+      transformed.authors = authors.map((author) => author.name);
+    }
+    this.config.collection.fields.forEach((field) => {
+      const value = post[field.name];
+      if (!transformed[field.name] && value !== void 0 && value !== null) {
+        transformed[field.name] = value;
+      }
+    });
+    console.log("Transformed document:", transformed);
+    return transformed;
+  }
+  /**
+   * Fetch all posts from Ghost and index them in Typesense
+   */
+  async indexAllPosts() {
+    let allPosts = [];
+    const posts = this.ghost.posts.browse({
+      limit: 15
+      // Default limit in Ghost
+    }).include({ tags: true, authors: true });
+    const response = await posts.fetch();
+    if (!response.success) {
+      throw new Error("Failed to fetch posts from Ghost");
+    }
+    allPosts = allPosts.concat(response.data);
+    const total = response.meta.pagination.total;
+    const limit = response.meta.pagination.limit;
+    const totalPages = Math.ceil(total / limit);
+    for (let page = 2; page <= totalPages; page++) {
+      const pageResponse = await this.ghost.posts.browse({
+        limit,
+        page
+      }).include({ tags: true, authors: true }).fetch();
+      if (!pageResponse.success) {
+        throw new Error(`Failed to fetch page ${page} from Ghost`);
+      }
+      allPosts = allPosts.concat(pageResponse.data);
+    }
+    console.log(`Found ${allPosts.length} posts to index`);
+    const documents = allPosts.map((post) => this.transformPost(post));
+    try {
+      const collection = this.typesense.collections(this.collectionName);
+      const results = await Promise.all(
+        documents.map(
+          (doc) => collection.documents().upsert(doc).then(() => ({ success: true, id: doc.id })).catch((error) => ({ success: false, id: doc.id, error: error.message }))
+        )
+      );
+      const succeeded = results.filter((r) => r.success).length;
+      const failed = results.filter((r) => !r.success).length;
+      console.log(`Indexing complete: ${succeeded} succeeded, ${failed} failed`);
+      if (failed > 0) {
+        console.log("Failed documents:", results.filter((r) => !r.success));
+      }
+    } catch (error) {
+      console.error("Indexing error:", error);
+      throw error;
+    }
+  }
+  /**
+   * Index a single post in Typesense
+   */
+  async indexPost(postId) {
+    const post = await this.ghost.posts.read({ id: postId }).include({ tags: true, authors: true }).fetch();
+    if (!post.success) {
+      throw new Error(`Failed to fetch post ${postId} from Ghost`);
+    }
+    const document = this.transformPost(post.data);
+    const collection = this.typesense.collections(this.collectionName);
+    await collection.documents().upsert(document);
+  }
+  /**
+   * Delete a post from Typesense
+   */
+  async deletePost(postId) {
+    const collection = this.typesense.collections(this.collectionName);
+    await collection.documents().delete({ filter_by: `id:${postId}` });
+  }
+  /**
+   * Clear all documents from the collection
+   */
+  async clearCollection() {
+    const collection = this.typesense.collections(this.collectionName);
+    await collection.documents().delete();
+  }
+};
+export {
+  GhostTypesenseManager
+};

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@magicpages/ghost-typesense-core",
+  "version": "0.0.0",
+  "description": "Core functionality for Ghost-Typesense integration",
+  "author": "MagicPages",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/magicpages/ghost-typesense.git",
+    "directory": "packages/core"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "clean": "rimraf dist",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "lint": "eslint src --ext .ts",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@magicpages/ghost-typesense-config": "*",
+    "@ts-ghost/content-api": "^4.0.6",
+    "@ts-ghost/core-api": "^4.0.6",
+    "typesense": "^1.7.2",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.17",
+    "tsup": "^8.0.1",
+    "rimraf": "^5.0.5",
+    "vitest": "^1.2.2",
+    "typescript": "^5.3.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}