PostArchiver

https://github.com/xiao-e-yun/postarchiver
Admin
PostArchiver is a unified archive library that provides type definitions and tools for archiving...
Tokens:4,708
Snippets:33
Trust Score:7.8
License:BSD-3-Clause
Update:7 months ago
Show doc for...
Tokens:
Raw
### Import Post types

Source: https://github.com/xiao-e-yun/postarchiver/blob/main/README.md

Example of how to import the Post type definition in a TypeScript project.

```typescript
import type { Post } from "post-archiver"
```

--------------------------------

### Install PostArchiver Library

Source: https://context7.com/xiao-e-yun/postarchiver/llms.txt

Instructions for installing the PostArchiver library for both Rust and TypeScript projects. For Rust, it uses Cargo. For TypeScript, it installs type definitions via npm.

```shell
# For Rust
cargo add post-archiver

# For TypeScript (type definitions only)
npm add -D post-archiver
```

--------------------------------

### Install PostArchiver package

Source: https://github.com/xiao-e-yun/postarchiver/blob/main/README.md

Instructions for adding the post-archiver dependency to your project. Supports both Rust via cargo and TypeScript via npm.

```rust
cargo add post-archiver
```

```typescript
npm add -D post-archiver
```

--------------------------------

### Implement Transaction Support with PostArchiverManager in Rust

Source: https://context7.com/xiao-e-yun/postarchiver/llms.txt

Shows how to use transactions with 'PostArchiverManager' in Rust to ensure atomicity for multiple database operations. It includes starting a transaction, performing operations within it, and committing the changes.

```rust
use post_archiver::manager::PostArchiverManager;

let mut manager = PostArchiverManager::open_or_create("./archive").unwrap();

// Start transaction
let mut tx = manager.transaction().unwrap();

// Perform multiple operations...
// tx.import_post(...)?;
// tx.import_author(...)?;

// Commit all changes
tx.commit().unwrap();
```

--------------------------------

### Build project and generate bindings

Source: https://github.com/xiao-e-yun/postarchiver/blob/main/README.md

Commands to build the project. For Rust, it uses standard cargo build; for TypeScript, it runs tests with the typescript feature flag followed by a generation script.

```rust
cargo build
```

```typescript
cargo test -F=typescript
node gen-types.mjs
```

--------------------------------

### Execute Fluent Queries and Pagination in Rust

Source: https://context7.com/xiao-e-yun/postarchiver/llms.txt

Shows how to use the fluent query builder to retrieve posts with pagination, sorting, and total count metadata. This interface supports both simple list retrieval and complex ordered queries.

```rust
use post_archiver::manager::PostArchiverManager;
use post_archiver::query::{Query, Paginate, Countable, Sortable, SortDir};
use post_archiver::query::post::PostSort;
use post_archiver::Post;

let manager = PostArchiverManager::open_or_create("./archive").unwrap();

// Simple query - get all posts
let posts: Vec<Post> = manager.posts().query().unwrap();

// Paginated query - page 0, 20 items per page
let posts: Vec<Post> = manager.posts()
    .pagination(20, 0)
    .query()
    .unwrap();

// Sorted query
let posts: Vec<Post> = manager.posts()
    .sort(PostSort::Updated, SortDir::Desc)
    .query()
    .unwrap();

// Paginated with total count
let result = manager.posts()
    .pagination(20, 0)
    .with_total()
    .query::<Post>()
    .unwrap();

println!("Page contains {} posts, total: {}", result.items.len(), result.total);

// Random ordering
let random_posts: Vec<Post> = manager.posts()
    .sort_random()
    .pagination(10, 0)
    .query()
    .unwrap();
```

--------------------------------

### Create, Open, and Manage Archives with PostArchiverManager in Rust

Source: https://context7.com/xiao-e-yun/postarchiver/llms.txt

Demonstrates how to use 'PostArchiverManager' in Rust for database operations. It covers creating a new archive, opening an existing one, opening or creating an archive, and using an in-memory database for testing.

```rust
use post_archiver::manager::PostArchiverManager;

// Create a new archive (fails if already exists)
let manager = PostArchiverManager::create("./my_archive").unwrap();

// Open existing archive (returns None if not found)
if let Some(manager) = PostArchiverManager::open("./my_archive").unwrap() {
    println!("Archive opened successfully");
}

// Open or create (convenient for most use cases)
let manager = PostArchiverManager::open_or_create("./my_archive").unwrap();

// In-memory database for testing
let manager = PostArchiverManager::open_in_memory().unwrap();
```

--------------------------------

### Query Additional Entities in Rust

Source: https://context7.com/xiao-e-yun/postarchiver/llms.txt

Demonstrates the consistent query pattern applied to other entities such as authors, tags, collections, and platforms.

```rust
use post_archiver::manager::PostArchiverManager;
use post_archiver::query::{Query, Paginate, Sortable, SortDir};
use post_archiver::query::author::AuthorSort;
use post_archiver::{Author, Tag, Collection, Platform};

let manager = PostArchiverManager::open_or_create("./archive").unwrap();

// Query authors
let authors: Vec<Author> = manager.authors()
    .sort(AuthorSort::Updated, SortDir::Desc)
    .pagination(20, 0)
    .query()
    .unwrap();

// Query tags
let tags: Vec<Tag> = manager.tags().query().unwrap();

// Query collections
let collections: Vec<Collection> = manager.collections().query().unwrap();

// Query platforms
let platforms: Vec<Platform> = manager.platforms().query().unwrap();
```

--------------------------------

### Import Posts with Content and Metadata (Rust)

Source: https://context7.com/xiao-e-yun/postarchiver/llms.txt

Imports posts along with all associated content, files, tags, and relationships. Handles file copying and metadata. Requires `post_archiver` and `chrono` crates.

```rust
use post_archiver::manager::PostArchiverManager;
use post_archiver::importer::{UnsyncPost, UnsyncContent, UnsyncFileMeta, UnsyncTag, UnsyncCollection};
use post_archiver::{PlatformId, AuthorId, Comment};
use chrono::Utc;
use std::path::PathBuf;

let manager = PostArchiverManager::open_or_create("./archive").unwrap();

// Create file metadata (with file path for later copying)
let image = UnsyncFileMeta::new(
    "artwork.png".to_string(),
    "image/png".to_string(),
    PathBuf::from("/tmp/downloaded/artwork.png"),
);

// Create unsynced post
let post = UnsyncPost::new(
    PlatformId::new(1),
    "https://fanbox.cc/posts/12345".to_string(),
    "My Latest Artwork".to_string(),
    vec![
        UnsyncContent::Text("Check out my new piece!".to_string()),
        UnsyncContent::File(image),
    ],
)
.authors(vec![AuthorId::new(1)])
.tags(vec![
    UnsyncTag::new("illustration".to_string()),
    UnsyncTag::new("fanart".to_string()),
])
.collections(vec![
    UnsyncCollection::new("2024 Collection".to_string()),
])
.comments(vec![
    Comment {
        user: "fan123".to_string(),
        text: "Beautiful!".to_string(),
        replies: vec![],
    },
])
.published(Utc::now())
.updated(Utc::now());

// Import post and move files to archive
let post_id = manager.import_post_with_rename_files(post).unwrap();
```

--------------------------------

### Perform Point Lookups in Rust

Source: https://context7.com/xiao-e-yun/postarchiver/llms.txt

Shows how to perform direct lookups for posts using unique identifiers or source URLs.

```rust
use post_archiver::manager::PostArchiverManager;
use post_archiver::PostId;

let manager = PostArchiverManager::open_or_create("./archive").unwrap();

// Get post by ID
if let Some(post) = manager.get_post(PostId::new(1)).unwrap() {
    println!("Found: {}", post.title);
}

// Find post by source URL
if let Some(post_id) = manager.find_post("https://fanbox.cc/posts/12345").unwrap() {
    println!("Post ID: {}", post_id);
}
```

--------------------------------

### Filter Posts by Criteria in Rust

Source: https://context7.com/xiao-e-yun/postarchiver/llms.txt

Illustrates how to apply various filters to the query builder, including ID inclusion, pattern matching on titles, date ranges, and relationship constraints.

```rust
use post_archiver::manager::PostArchiverManager;
use post_archiver::query::Query;
use post_archiver::{Post, PostId, AuthorId, TagId, PlatformId};
use chrono::{Utc, Duration};

let manager = PostArchiverManager::open_or_create("./archive").unwrap();

// Filter by IDs
let mut query = manager.posts();
query.ids.include.push(PostId::new(1));
query.ids.include.push(PostId::new(2));
let posts: Vec<Post> = query.query().unwrap();

// Filter by title (LIKE pattern)
let mut query = manager.posts();
query.title.like = Some("%artwork%".to_string());
let posts: Vec<Post> = query.query().unwrap();

// Filter by date range
let mut query = manager.posts();
query.published.after = Some(Utc::now() - Duration::days(30));
query.published.before = Some(Utc::now());
let recent_posts: Vec<Post> = query.query().unwrap();

// Filter by platform
let mut query = manager.posts();
query.platforms.include.push(PlatformId::new(1));
let posts: Vec<Post> = query.query().unwrap();

// Filter by relationships (posts with specific tags AND authors)
let mut query = manager.posts();
query.tags.must_have.push(TagId::new(1));
query.authors.must_have.push(AuthorId::new(1));
let filtered: Vec<Post> = query.query().unwrap();
```

--------------------------------

### Import File Metadata (Rust)

Source: https://context7.com/xiao-e-yun/postarchiver/llms.txt

Imports file metadata for a post, offering strategies for file handling such as moving/renaming files or providing content directly as bytes. Requires the `post_archiver` crate.

```rust
use post_archiver::manager::PostArchiverManager;
use post_archiver::importer::UnsyncFileMeta;
use post_archiver::PostId;
use std::path::PathBuf;

let manager = PostArchiverManager::open_or_create("./archive").unwrap();
let post_id = PostId::new(1);

// With PathBuf - file will be moved/renamed
let file_meta = UnsyncFileMeta::new(
    "image.png".to_string(),
    "image/png".to_string(),
    PathBuf::from("/tmp/downloaded/image.png"),
);

// Import metadata only (database entry)
let file_id = manager.import_file_meta(post_id, &file_meta).unwrap();

// Import and move file to archive
let file_id = manager.import_file_meta_by_rename(post_id, &file_meta).unwrap();

// With byte vector - file content provided directly
let file_with_bytes = UnsyncFileMeta::new(
    "text.txt".to_string(),
    "text/plain".to_string(),
    b"Hello, World!".to_vec(),
);

// Import and write content to archive
let file_id = manager.import_file_meta_with_content(post_id, &file_with_bytes).unwrap();
```

--------------------------------

### Bulk Import Posts (Rust)

Source: https://context7.com/xiao-e-yun/postarchiver/llms.txt

Efficiently imports multiple posts in a single operation, including batch relationship updates and file handling. Requires the `post_archiver` crate.

```rust
use post_archiver::manager::PostArchiverManager;
use post_archiver::importer::{UnsyncPost, UnsyncContent};
use post_archiver::PlatformId;
use std::path::PathBuf;

let manager = PostArchiverManager::open_or_create("./archive").unwrap();

let posts = vec![
    UnsyncPost::new(
        PlatformId::new(1),
        "https://example.com/post/1".to_string(),
        "Post 1".to_string(),
        vec![UnsyncContent::Text("Content 1".to_string())],
    ),
    UnsyncPost::new(
        PlatformId::new(1),
        "https://example.com/post/2".to_string(),
        "Post 2".to_string(),
        vec![UnsyncContent::Text("Content 2".to_string())],
    ),
];

// Import multiple posts, moving files and updating relations
let post_ids = manager.import_posts_with_rename_files(posts).unwrap();
println!("Imported {} posts", post_ids.len());
```

--------------------------------

### Import Authors with Aliases (Rust)

Source: https://context7.com/xiao-e-yun/postarchiver/llms.txt

Imports authors with cross-platform aliases, automatically deduplicating entries based on the aliases. Requires the `post_archiver` crate.

```rust
use post_archiver::manager::PostArchiverManager;
use post_archiver::importer::{UnsyncAuthor, UnsyncAlias};
use post_archiver::PlatformId;

let manager = PostArchiverManager::open_or_create("./archive").unwrap();

// Create an unsynced author with aliases
let author = UnsyncAuthor::new("ArtistName".to_string())
    .aliases(vec![
        UnsyncAlias::new(PlatformId::new(1), "artist_12345".to_string())
            .link("https://fanbox.cc/@artist".to_string()),
        UnsyncAlias::new(PlatformId::new(2), "artist_pixiv".to_string())
            .link("https://pixiv.net/users/12345".to_string()),
    ]);

// Import (deduplicates by alias)
let author_id = manager.import_author(author).unwrap();
// Or use the builder pattern:
// let author_id = author.sync(&manager).unwrap();
```

--------------------------------

### Bind Entities for CRUD Operations in Rust

Source: https://context7.com/xiao-e-yun/postarchiver/llms.txt

Demonstrates how to use the PostArchiverManager to bind specific entities like posts or authors for updates, relation management, and deletion. This approach provides a scoped context for performing targeted modifications on stored data.

```rust
use post_archiver::manager::{PostArchiverManager, UpdatePost, UpdateAuthor};
use post_archiver::{PostId, AuthorId, TagId};
use chrono::Utc;

let manager = PostArchiverManager::open_or_create("./archive").unwrap();

// Bind a post ID to perform operations
let post_id = PostId::new(1);
let binded_post = manager.bind(post_id);

// Update post fields
binded_post.update(
    UpdatePost::default()
        .title("New Title".to_string())
        .updated(Utc::now())
).unwrap();

// Manage post relations
binded_post.add_tags(&[TagId::new(1), TagId::new(2)]).unwrap();
binded_post.add_authors(&[AuthorId::new(1)]).unwrap();
binded_post.remove_tags(&[TagId::new(1)]).unwrap();

// Delete a post
manager.bind(PostId::new(2)).delete().unwrap();

// Update author with auto-computed fields
let author_id = AuthorId::new(1);
manager.bind(author_id).update(
    UpdateAuthor::default()
        .name("Updated Name".to_string())
        .thumb_by_latest()      // Set thumb from most recent post
        .updated_by_latest()    // Set updated from most recent post
).unwrap();
```

--------------------------------

### Define FileMeta Structure and Path Generation in Rust

Source: https://context7.com/xiao-e-yun/postarchiver/llms.txt

Shows the 'FileMeta' structure in Rust for storing file metadata, including its ID, associated post, filename, MIME type, and extra data. It also demonstrates the `path()` method for automatic file organization based on post chunking.

```rust
use post_archiver::{FileMeta, FileMetaId, PostId};
use std::collections::HashMap;

let file_meta = FileMeta {
    id: FileMetaId::new(6),
    post: PostId::new(2049),
    filename: "artwork.png".to_string(),
    mime: "image/png".to_string(),
    extra: HashMap::new(),
};

// Files are organized as: <chunk>/<index>/<filename>
// chunk = postId / 2048, index = postId % 2048
let path = file_meta.path();
assert_eq!(path.to_str(), Some("1/1/artwork.png"));
```

--------------------------------

### Define Post Structure in Rust

Source: https://context7.com/xiao-e-yun/postarchiver/llms.txt

Demonstrates the structure of a 'Post' object in Rust, including its ID, source URL, title, content (text and file references), thumbnail, comments, update/publish timestamps, and platform ID. Uses chrono for timestamps.

```rust
use post_archiver::{Post, PostId, Content, Comment, FileMetaId, PlatformId};
use chrono::Utc;

// Post structure
let post = Post {
    id: PostId::new(1),
    source: Some("https://fanbox.cc/posts/12345".to_string()),
    title: "My Artwork".to_string(),
    content: vec![
        Content::Text("# Introduction\nHere's my latest work!".to_string()),
        Content::File(FileMetaId::new(1)),
        Content::Text("*Thanks for your support!*".to_string()),
    ],
    thumb: Some(FileMetaId::new(1)),
    comments: vec![
        Comment {
            user: "supporter123".to_string(),
            text: "Amazing work!".to_string(),
            replies: vec![],
        },
    ],
    updated: Utc::now(),
    published: Utc::now(),
    platform: Some(PlatformId::new(1)),
};
```

--------------------------------

### Define Author and Alias Structures in Rust

Source: https://context7.com/xiao-e-yun/postarchiver/llms.txt

Illustrates the 'Author' and 'Alias' structures in Rust for managing content creators and their cross-platform identities. 'Author' holds canonical information, while 'Alias' links platform-specific IDs to a canonical 'AuthorId'.

```rust
use post_archiver::{Author, Alias, AuthorId, FileMetaId, PlatformId};
use chrono::Utc;

// Author structure
let author = Author {
    id: AuthorId::new(1),
    name: "ArtistName".to_string(),
    thumb: Some(FileMetaId::new(1)),
    updated: Utc::now(),
};

// Alias for cross-platform identity
let alias = Alias {
    source: "artist_12345".to_string(),           // Platform-specific ID
    platform: PlatformId::new(1),                  // e.g., Fanbox
    target: AuthorId::new(1),                      // Maps to canonical author
    link: Some("https://fanbox.cc/@artist".to_string()),
};
```

--------------------------------

### Import TypeScript Types for PostArchiver

Source: https://context7.com/xiao-e-yun/postarchiver/llms.txt

Imports essential type definitions from the 'post-archiver' package for use in frontend applications. These types define the structure of content elements like posts, authors, tags, and collections, enabling type-safe data handling and development.

```typescript
import type {
    Post,
    Author,
    Alias,
    Tag,
    Collection,
    FileMeta,
    Platform,
    Comment,
    Content,
    PostId,
    AuthorId,
    TagId,
    FileMetaId,
    PlatformId,
    CollectionId
} from "post-archiver";

// Example usage in a React component
interface PostListProps {
    posts: Post[];
}

function PostList({ posts }: PostListProps) {
    return (
        <ul>
            {posts.map(post => (
                <li key={post.id}>
                    <h3>{post.title}</h3>
                    <time>{post.published}</time>
                </li>
            ))}
        </ul>
    );
}
```

--------------------------------

### Define Content Enum Variants in Rust

Source: https://context7.com/xiao-e-yun/postarchiver/llms.txt

Illustrates the 'Content' enum in Rust, which represents different types of content within a post. It supports plain text (with Markdown) and references to files via 'FileMetaId'.

```rust
use post_archiver::{Content, FileMetaId};

// Text content with markdown
let text = Content::Text("# Heading\n\nSome **bold** text".to_string());

// File reference
let image = Content::File(FileMetaId::new(1));

// Mixed content array for a post
let contents = vec![
    Content::Text("Introduction:".to_string()),
    Content::File(FileMetaId::new(1)),
    Content::Text("*Caption for the above image*".to_string()),
];
```
Tokens:
Raw