@skills-store/rednote 0.1.14 → 0.1.16

package/dist/rednote/persistence.js

@@ -289,6 +289,96 @@ const rednotePostCommentSchema = new EntitySchema({
         }
     ]
 });
+const rednoteProfileSchema = new EntitySchema({
+    name: 'RednoteProfileRecord',
+    tableName: 'rednote_profiles',
+    columns: {
+        id: {
+            type: String,
+            primary: true,
+            length: 16
+        },
+        userId: {
+            name: 'userid',
+            type: String
+        },
+        nickname: {
+            type: String,
+            nullable: true
+        },
+        desc: {
+            type: 'text',
+            nullable: true
+        },
+        avatar: {
+            type: String,
+            nullable: true
+        },
+        ipLocation: {
+            name: 'ip_location',
+            type: String,
+            nullable: true
+        },
+        gender: {
+            type: String,
+            nullable: true
+        },
+        follows: {
+            type: String,
+            nullable: true
+        },
+        fans: {
+            type: String,
+            nullable: true
+        },
+        interaction: {
+            type: String,
+            nullable: true
+        },
+        tags: {
+            type: 'simple-json',
+            nullable: true
+        },
+        fetchedAt: {
+            name: 'fetched_at',
+            type: Date
+        },
+        instanceName: {
+            name: 'instance_name',
+            type: String
+        },
+        raw: {
+            type: 'simple-json',
+            nullable: true
+        },
+        createdAt: {
+            name: 'created_at',
+            type: Date,
+            createDate: true
+        }
+    },
+    indices: [
+        {
+            name: 'IDX_rednote_profiles_userid_instance',
+            columns: [
+                'userId',
+                'instanceName'
+            ]
+        },
+        {
+            name: 'IDX_rednote_profiles_fetched_at',
+            columns: [
+                'fetchedAt'
+            ]
+        },
+        {
+            name: 'IDX_rednote_profiles_instance',
+            columns: [
+                'instanceName'
+            ]
+        }
+    ]
+});
 let dataSourcePromise = null;
 function createRecordId() {
     return nanoid(16);
@@ -360,7 +450,8 @@ async function initializeDataSource() {
         entities: [
             rednotePostSchema,
             rednotePostDetailSchema,
-            rednotePostCommentSchema
+            rednotePostCommentSchema,
+            rednoteProfileSchema
         ],
         synchronize: true,
         logging: false,
@@ -576,3 +667,98 @@ export async function findPersistedPostUrlByRecordId(instanceName, id) {
     });
     return row?.url ?? null;
 }
+export async function persistProfile(input) {
+    const { instanceName, result } = input;
+    const { profile } = result;
+    const { user, notes, userId, url, fetchedAt } = profile;
+    const dataSource = await initializeRednoteDatabase();
+    await dataSource.transaction(async (manager)=>{
+        const profileRepository = manager.getRepository(rednoteProfileSchema);
+        const postRepository = manager.getRepository(rednotePostSchema);
+        await profileRepository.save(profileRepository.create({
+            id: createRecordId(),
+            userId,
+            nickname: user.nickname,
+            desc: user.desc,
+            avatar: user.avatar,
+            ipLocation: user.ipLocation,
+            gender: user.gender,
+            follows: toCountString(user.follows),
+            fans: toCountString(user.fans),
+            interaction: toCountString(user.interaction),
+            tags: user.tags,
+            fetchedAt: new Date(fetchedAt),
+            instanceName,
+            raw: user
+        }));
+        if (notes.length > 0) {
+            const noteIds = uniqueStrings(notes.map((note)=>note.id));
+            const existingRows = noteIds.length > 0 ? await postRepository.find({
+                where: {
+                    instanceName,
+                    noteId: In(noteIds)
+                }
+            }) : [];
+            const existingMap = new Map(existingRows.map((row)=>[
+                    row.noteId,
+                    row
+                ]));
+            const entities = notes.map((post)=>{
+                const existing = existingMap.get(post.id);
+                const image = extractPrimaryImage(post);
+                const authorNickname = firstNonEmpty(post.noteCard.user.nickname, post.noteCard.user.nickName);
+                return postRepository.create({
+                    id: existing?.id ?? createRecordId(),
+                    noteId: post.id,
+                    title: coalesceValue(post.noteCard.displayTitle, existing?.title),
+                    url: coalesceValue(post.url, existing?.url),
+                    image: coalesceValue(image, existing?.image),
+                    likeCount: coalesceValue(toCountString(post.noteCard.interactInfo.likedCount), existing?.likeCount),
+                    commentCount: coalesceValue(toCountString(post.noteCard.interactInfo.commentCount), existing?.commentCount),
+                    collectedCount: coalesceValue(toCountString(post.noteCard.interactInfo.collectedCount), existing?.collectedCount),
+                    sharedCount: coalesceValue(toCountString(post.noteCard.interactInfo.sharedCount), existing?.sharedCount),
+                    authorId: coalesceValue(post.noteCard.user.userId, existing?.authorId),
+                    authorNickname: coalesceValue(authorNickname, existing?.authorNickname),
+                    modelType: coalesceValue(post.modelType, existing?.modelType),
+                    xsecToken: coalesceValue(post.xsecToken, existing?.xsecToken),
+                    instanceName,
+                    raw: post,
+                    ...existing?.createdAt ? {
+                        createdAt: existing.createdAt
+                    } : {}
+                });
+            });
+            await postRepository.save(entities);
+        }
+    });
+}
+export async function getProfileHistory(instanceName, userId, options) {
+    const dataSource = await initializeRednoteDatabase();
+    const repository = dataSource.getRepository(rednoteProfileSchema);
+    const rows = await repository.find({
+        where: {
+            instanceName,
+            userId
+        },
+        order: {
+            fetchedAt: 'DESC'
+        },
+        take: options?.limit ?? 100
+    });
+    return rows.map((row)=>({
+            id: row.id,
+            userId: row.userId,
+            nickname: row.nickname,
+            desc: row.desc,
+            avatar: row.avatar,
+            ipLocation: row.ipLocation,
+            gender: row.gender,
+            follows: row.follows,
+            fans: row.fans,
+            interaction: row.interaction,
+            tags: row.tags,
+            fetchedAt: row.fetchedAt,
+            instanceName: row.instanceName,
+            createdAt: row.createdAt
+        }));
+}

package/dist/rednote/status.js

@@ -23,6 +23,9 @@ Usage:
 Options:
   --instance NAME   Show status for a custom instance or default browser instance
   -h, --help        Show this help
+
+Notes:
+  When called without --instance, it uses the last connected instance from data.json (lastConnect).
 `);
 }
 function toInstanceState(instance) {
@@ -136,6 +139,7 @@ export async function getRednoteStatus(target) {
                 checked
             });
             rednote = {
+                userId: checked.userId,
                 loginStatus: checked.loginStatus,
                 lastLoginAt: checked.lastLoginAt
             };

package/dist/utils/browser-cli.js

@@ -103,6 +103,7 @@ Usage:
   bun ./scripts/browser/connect-browser.ts [--instance NAME] [--browser chrome|edge|chromium|brave] [--user-data-dir PATH] [--force] [--port 9222]
 
 Notes:
+  When called without --instance, it uses the last connected instance from data.json (lastConnect).
   When using --instance without --port, the stored instance port from data.json is used.
   If no stored port exists yet, a random free port is assigned and saved for next time.
 `);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skills-store/rednote",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "private": false,
   "type": "module",
   "bin": {