beamsocial 0.2.0 → 0.4.0

package/lib/index.d.ts

@@ -1,10 +1,11 @@
 import type { ProfileSettings } from './models/types/profiles.js';
 import { User } from './models/users.js';
 import { Session } from './models/auth.js';
+import { Post } from './models/posts.js';
 export declare class Client {
     private readonly baseURL;
-    private token;
-    private session;
+    private token?;
+    private session?;
     constructor(baseURL: string, token?: string);
     login(username: string, password: string): Promise<Session | null>;
     refresh(token?: string): Promise<void>;
@@ -12,6 +13,11 @@ export declare class Client {
     update_settings(settings: ProfileSettings): Promise<void>;
     /*************************************/
     getUser(name: string): Promise<User | null>;
+    /*************************************/
+    writePost(content: string, visibility?: "me" | "friends" | "followers" | "everyone"): Promise<Post>;
+    getPost(id: string): Promise<Post>;
+    fetchUserPosts(name: string): Promise<Post[]>;
 }
 export { User } from './models/users.js';
 export { Session } from './models/auth.js';
+export { Post } from './models/posts.js';

package/lib/index.js

@@ -10,10 +10,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import axios from 'axios';
 import { User } from './models/users.js';
 import { Session } from './models/auth.js';
+import { Post } from './models/posts.js';
 export class Client {
     constructor(baseURL, token) {
-        this.token = null;
-        this.session = null;
         this.baseURL = baseURL;
         if (token)
             this.token = token;
@@ -23,7 +22,7 @@ export class Client {
             try {
                 const res = yield axios.post(this.baseURL + '/auth/login', { username, password });
                 yield this.refresh(res.data.token);
-                return this.session;
+                return this.session || null;
             }
             catch (err) {
                 if (axios.isAxiosError(err) && err.response) {
@@ -46,7 +45,7 @@ export class Client {
             if (token)
                 this.token = token;
             let session = yield this.me();
-            this.session = session;
+            this.session = session || undefined;
         });
     }
     me() {
@@ -58,7 +57,7 @@ export class Client {
                     },
                 });
                 let session;
-                session = new Session(res.data.id, this.token);
+                session = new Session(res.data.id, this.token || null);
                 session.__load(res.data);
                 return session;
             }
@@ -118,15 +117,15 @@ export class Client {
                     },
                 });
                 let user;
-                user = new User(res.data.id, this.token, this.baseURL + '/users/' + name);
-                user.__load(res.data);
+                user = new User(res.data.id);
+                user.__load(res.data, this.token, this.baseURL);
                 return user;
             }
             catch (err) {
                 if (axios.isAxiosError(err) && err.response) {
                     const res = err.response;
                     if (res.status === 403) {
-                        throw new Error('User is private');
+                        throw new Error('Private account');
                     }
                     else if (res.status === 404) {
                         return null;
@@ -141,6 +140,117 @@ export class Client {
             }
         });
     }
+    /*************************************/
+    writePost(content_1) {
+        return __awaiter(this, arguments, void 0, function* (content, visibility = "followers") {
+            try {
+                const res = yield axios.post(this.baseURL + '/posts/new', {
+                    content: content,
+                    visibility: visibility
+                }, {
+                    headers: {
+                        Authorization: `Bearer ${this.token}`,
+                    },
+                });
+                const data = res.data;
+                const post = new Post(data.id);
+                post.__load(data, this.token, this.baseURL);
+                return post;
+            }
+            catch (err) {
+                if (axios.isAxiosError(err) && err.response) {
+                    const res = err.response;
+                    if (res.status == 401) {
+                        throw new Error('Not logged in');
+                    }
+                    else if (res.status == 413) {
+                        throw new Error('Post too long');
+                    }
+                    else {
+                        throw new Error('Error writing post');
+                    }
+                }
+                else {
+                    throw err;
+                }
+            }
+        });
+    }
+    getPost(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const res = yield axios.get(this.baseURL + '/posts/' + id, {
+                    headers: {
+                        Authorization: `Bearer ${this.token}`,
+                    },
+                });
+                const data = res.data;
+                const post = new Post(data.id);
+                post.__load(data, this.token, this.baseURL);
+                return post;
+            }
+            catch (err) {
+                if (axios.isAxiosError(err) && err.response) {
+                    const res = err.response;
+                    if (res.status == 401) {
+                        throw new Error('Not logged in');
+                    }
+                    else if (res.status == 403) {
+                        throw new Error('Private account');
+                    }
+                    else if (res.status == 404) {
+                        throw new Error('Post not found');
+                    }
+                    else {
+                        throw new Error('Error writing post');
+                    }
+                }
+                else {
+                    throw err;
+                }
+            }
+        });
+    }
+    fetchUserPosts(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const res = yield axios.get(this.baseURL + '/users/' + name + `/posts`, {
+                    headers: {
+                        Authorization: `Bearer ${this.token}`,
+                    },
+                });
+                const data = res.data;
+                const posts = [];
+                for (const p of data) {
+                    let new_p = new Post(p.id);
+                    new_p.__load(p, this.token, this.baseURL);
+                    posts.push(new_p);
+                }
+                return posts;
+            }
+            catch (err) {
+                if (axios.isAxiosError(err) && err.response) {
+                    const res = err.response;
+                    if (res.status == 401) {
+                        throw new Error('Not logged in');
+                    }
+                    else if (res.status == 403) {
+                        throw new Error('Private account');
+                    }
+                    else if (res.status == 404) {
+                        throw new Error('User not found');
+                    }
+                    else {
+                        throw new Error('Error fetching posts');
+                    }
+                }
+                else {
+                    throw err;
+                }
+            }
+        });
+    }
 }
 export { User } from './models/users.js';
 export { Session } from './models/auth.js';
+export { Post } from './models/posts.js';

package/lib/models/auth.d.ts

@@ -1,11 +1,11 @@
 import type { Profile, ProfileSettings } from "./types/profiles";
 export declare class Session {
     readonly id: string;
-    readonly token: string;
+    readonly token: string | null;
     profile: Profile;
     settings: ProfileSettings;
     inbox: {};
-    constructor(id: string, token: string);
+    constructor(id: string, token: string | null);
     __load(data: {
         profile?: Profile;
         settings?: ProfileSettings;

package/lib/models/auth.js

@@ -1,5 +1,6 @@
 export class Session {
     constructor(id, token) {
+        this.token = null;
         this.profile = {};
         this.settings = {};
         this.inbox = {};

package/lib/models/posts.d.ts

@@ -0,0 +1,24 @@
+import type { RawPost, RawComment, RawFile } from "./types/interactions";
+import { User } from "./users.js";
+export declare class Post {
+    private __token?;
+    private __url?;
+    id: string;
+    author: User | null;
+    content: string;
+    attachments: RawFile[];
+    visibility: "everyone" | "followers" | "friends" | "me";
+    likes: string[];
+    reposts: string[];
+    comments: RawComment[];
+    constructor(id: string);
+    __load(data: RawPost, __token?: string, __url?: string): void;
+    like(): Promise<void>;
+    unlike(): Promise<void>;
+    repost(): Promise<void>;
+    undo_repost(): Promise<void>;
+    add_comment(comment: RawComment): Promise<void>;
+    remove_comment(comment: RawComment): Promise<void>;
+    report(): Promise<void>;
+    delete(): Promise<void>;
+}

package/lib/models/posts.js

@@ -0,0 +1,58 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { User } from "./users.js";
+export class Post {
+    constructor(id) {
+        this.author = null;
+        this.content = '';
+        this.attachments = [];
+        this.visibility = "followers";
+        this.likes = [];
+        this.reposts = [];
+        this.comments = [];
+        this.id = id;
+    }
+    __load(data, __token, __url) {
+        this.__token = __token;
+        this.__url = __url + '/posts/' + data.id;
+        this.author = new User(data.author.id);
+        this.author.__load(data.author, __token, __url + '/users/' + data.author.name);
+        this.content = data.content;
+        this.attachments = data.attachments;
+        this.visibility = data.visibility;
+        this.likes = data.likes;
+        this.reposts = data.reposts;
+        this.comments = data.comments;
+    }
+    like() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    unlike() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    repost() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    undo_repost() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    add_comment(comment) {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    remove_comment(comment) {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    report() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    delete() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+}

package/lib/models/types/interactions.d.ts

@@ -1,19 +1,28 @@
-export type Post = {
+import { Profile } from "./profiles";
+export type RawFile = {
     id: string;
     author_id: string;
-    content: string;
-    attachements: string[];
-    visibility: number;
-    likes: string[];
-    reposts: string[];
-    comments: string[];
+    path: string;
+    type: string;
+    date: string;
+    hidden: boolean;
 };
-export type Comment = {
+export type RawComment = {
     id: string;
     author_id: string;
     parent_id: string;
     post_id: string;
     content: string;
-    visibility: number;
+    visibility: "everyone" | "followers" | "friends" | "me";
+    likes: string[];
+};
+export type RawPost = {
+    id: string;
+    author: Profile;
+    content: string;
+    attachments: RawFile[];
+    visibility: "everyone" | "followers" | "friends" | "me";
     likes: string[];
+    reposts: string[];
+    comments: RawComment[];
 };

package/lib/models/users.d.ts

@@ -1,7 +1,7 @@
 import type { Profile } from "./types/profiles";
 export declare class User {
-    private readonly __token?;
-    private readonly __url?;
+    private __token?;
+    private __url?;
     id: string;
     name: string;
     display_name: string | null;
@@ -14,9 +14,8 @@ export declare class User {
     pronouns: string | null;
     account_type: string | null;
     level: number;
-    constructor(id: string, __token?: string, __url?: string);
-    __load(data: Profile): void;
-    getPosts(): Promise<any>;
+    constructor(id: string);
+    __load(data: Profile, __token?: string, __url?: string): void;
     follow(): Promise<void>;
     unfollow(): Promise<void>;
     block(): Promise<void>;

package/lib/models/users.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import axios from "axios";
 export class User {
-    constructor(id, __token, __url) {
+    constructor(id) {
         this.name = '';
         this.display_name = null;
         this.creation_date = '1970-01-01T00:00:00Z';
@@ -22,10 +22,10 @@ export class User {
         this.account_type = null;
         this.level = 0;
         this.id = id;
+    }
+    __load(data, __token, __url) {
         this.__token = __token;
         this.__url = __url;
-    }
-    __load(data) {
         this.name = data.name;
         this.display_name = data.display_name;
         this.creation_date = data.creation_date;
@@ -38,38 +38,6 @@ export class User {
         this.account_type = data.account_type;
         this.level = data.level;
     }
-    getPosts() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const res = yield axios.get(this.__url + `/posts`, {
-                    headers: {
-                        Authorization: `Bearer ${this.__token}`,
-                    },
-                });
-                return res.data;
-            }
-            catch (err) {
-                if (axios.isAxiosError(err) && err.response) {
-                    const res = err.response;
-                    if (res.status == 401) {
-                        throw new Error('Not logged in');
-                    }
-                    else if (res.status == 403) {
-                        throw new Error('Private account');
-                    }
-                    else if (res.status == 404) {
-                        throw new Error('User not found');
-                    }
-                    else {
-                        throw new Error('Error following user');
-                    }
-                }
-                else {
-                    throw err;
-                }
-            }
-        });
-    }
     follow() {
         return __awaiter(this, void 0, void 0, function* () {
             try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "beamsocial",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "type": "module",
   "description": "API-wrapper pour Beam",
   "main": "index.js",