feeds-fun 0.0.4

package/src/logic/types.ts

@@ -0,0 +1,371 @@
+import * as e from "@/logic/enums";
+
+export type FeedId = string & {readonly __brand: unique symbol};
+
+export function toFeedId(id: string): FeedId {
+  return id as FeedId;
+}
+
+export type EntryId = string & {readonly __brand: unique symbol};
+
+export function toEntryId(id: string): EntryId {
+  return id as EntryId;
+}
+
+export type RuleId = string & {readonly __brand: unique symbol};
+
+export function toRuleId(id: string): RuleId {
+  return id as RuleId;
+}
+
+export type FeedsCollectionId = string & {readonly __brand: unique symbol};
+
+export function toFeedsCollectionId(id: string): FeedsCollectionId {
+  return id as FeedsCollectionId;
+}
+
+export type URL = string & {readonly __brand: unique symbol};
+
+export function toURL(url: string): URL {
+  return url as URL;
+}
+
+export class Feed {
+  readonly id: FeedId;
+  readonly title: string | null;
+  readonly description: string | null;
+  readonly url: URL;
+  readonly state: string;
+  readonly lastError: string | null;
+  readonly loadedAt: Date | null;
+  readonly linkedAt: Date;
+  readonly isOk: boolean;
+
+  constructor({
+    id,
+    title,
+    description,
+    url,
+    state,
+    lastError,
+    loadedAt,
+    linkedAt,
+    isOk
+  }: {
+    id: FeedId;
+    title: string | null;
+    description: string | null;
+    url: URL;
+    state: string;
+    lastError: string | null;
+    loadedAt: Date | null;
+    linkedAt: Date;
+    isOk: boolean;
+  }) {
+    this.id = id;
+    this.title = title;
+    this.description = description;
+    this.url = url;
+    this.state = state;
+    this.lastError = lastError;
+    this.loadedAt = loadedAt;
+    this.linkedAt = linkedAt;
+    this.isOk = isOk;
+  }
+}
+
+export function feedFromJSON({
+  id,
+  title,
+  description,
+  url,
+  state,
+  lastError,
+  loadedAt,
+  linkedAt
+}: {
+  id: string;
+  title: string;
+  description: string;
+  url: string;
+  state: string;
+  lastError: string | null;
+  loadedAt: string;
+  linkedAt: string;
+}): Feed {
+  return {
+    id: toFeedId(id),
+    title: title !== null ? title : null,
+    description: description !== null ? description : null,
+    url: toURL(url),
+    state: state,
+    lastError: lastError,
+    loadedAt: loadedAt !== null ? new Date(loadedAt) : null,
+    linkedAt: new Date(linkedAt),
+    isOk: state === "loaded"
+  };
+}
+
+export class Entry {
+  readonly id: EntryId;
+  readonly feedId: FeedId;
+  readonly title: string;
+  readonly url: URL;
+  readonly tags: string[];
+  readonly markers: e.Marker[];
+  readonly score: number;
+  readonly scoreToZero: number;
+  readonly publishedAt: Date;
+  readonly catalogedAt: Date;
+  body: string | null;
+
+  constructor({
+    id,
+    feedId,
+    title,
+    url,
+    tags,
+    markers,
+    score,
+    publishedAt,
+    catalogedAt,
+    body
+  }: {
+    id: EntryId;
+    feedId: FeedId;
+    title: string;
+    url: URL;
+    tags: string[];
+    markers: e.Marker[];
+    score: number;
+    publishedAt: Date;
+    catalogedAt: Date;
+    body: string | null;
+  }) {
+    this.id = id;
+    this.feedId = feedId;
+    this.title = title;
+    this.url = url;
+    this.tags = tags;
+    this.markers = markers;
+    this.score = score;
+    this.publishedAt = publishedAt;
+    this.catalogedAt = catalogedAt;
+    this.body = body;
+
+    this.scoreToZero = -Math.abs(score);
+  }
+
+  setMarker(marker: e.Marker): void {
+    if (!this.hasMarker(marker)) {
+      this.markers.push(marker);
+    }
+  }
+
+  removeMarker(marker: e.Marker): void {
+    if (this.hasMarker(marker)) {
+      this.markers.splice(this.markers.indexOf(marker), 1);
+    }
+  }
+
+  hasMarker(marker: e.Marker): boolean {
+    return this.markers.includes(marker);
+  }
+}
+
+export function entryFromJSON({
+  id,
+  feedId,
+  title,
+  url,
+  tags,
+  markers,
+  score,
+  publishedAt,
+  catalogedAt,
+  body
+}: {
+  id: string;
+  feedId: string;
+  title: string;
+  url: string;
+  tags: string[];
+  markers: string[];
+  score: number;
+  publishedAt: string;
+  catalogedAt: string;
+  body: string | null;
+}): Entry {
+  return new Entry({
+    id: toEntryId(id),
+    feedId: toFeedId(feedId),
+    title,
+    url: toURL(url),
+    tags: tags,
+    markers: markers.map((m: string) => {
+      if (m in e.reverseMarker) {
+        return e.reverseMarker[m];
+      }
+
+      throw new Error(`Unknown marker: ${m}`);
+    }),
+    score: score,
+    publishedAt: new Date(publishedAt),
+    catalogedAt: new Date(catalogedAt),
+    body: body
+  });
+}
+
+export type Rule = {
+  readonly id: RuleId;
+  readonly tags: string[];
+  readonly score: number;
+  readonly createdAt: Date;
+};
+
+export function ruleFromJSON({
+  id,
+  tags,
+  score,
+  createdAt
+}: {
+  id: string;
+  tags: string[];
+  score: number;
+  createdAt: string;
+}): Rule {
+  return {
+    id: toRuleId(id),
+    tags: tags,
+    score: score,
+    createdAt: new Date(createdAt)
+  };
+}
+
+export type EntryInfo = {
+  readonly title: string;
+  readonly body: string;
+  readonly url: URL;
+  readonly publishedAt: Date;
+};
+
+export function entryInfoFromJSON({
+  title,
+  body,
+  url,
+  publishedAt
+}: {
+  title: string;
+  body: string;
+  url: string;
+  publishedAt: string;
+}): EntryInfo {
+  return {title, body, url: toURL(url), publishedAt: new Date(publishedAt)};
+}
+
+export type FeedInfo = {
+  readonly url: URL;
+  readonly title: string;
+  readonly description: string;
+  readonly entries: EntryInfo[];
+};
+
+export function feedInfoFromJSON({
+  url,
+  title,
+  description,
+  entries
+}: {
+  url: string;
+  title: string;
+  description: string;
+  entries: any[];
+}): FeedInfo {
+  return {
+    url: toURL(url),
+    title,
+    description,
+    entries: entries.map(entryInfoFromJSON)
+  };
+}
+
+export type TagInfo = {
+  readonly uid: string;
+  readonly name: string | null;
+  readonly link: string | null;
+  readonly categories: string[];
+};
+
+export function tagInfoFromJSON({
+  uid,
+  name,
+  link,
+  categories
+}: {
+  uid: string;
+  name: string | null;
+  link: string | null;
+  categories: string[];
+}): TagInfo {
+  return {uid, name: name, link: link, categories};
+}
+
+export function noInfoTag(uid: string): TagInfo {
+  return {uid, name: null, link: null, categories: []};
+}
+
+export type UserSetting = {
+  readonly kind: string;
+  readonly type: string;
+  value: string | number | boolean;
+  readonly name: string;
+  readonly description: string;
+};
+
+export function userSettingFromJSON({
+  kind,
+  type,
+  value,
+  name,
+  description
+}: {
+  kind: string;
+  type: string;
+  value: string | number | boolean;
+  name: string;
+  description: string;
+}): UserSetting {
+  return {kind, type, value, name, description};
+}
+
+export class ResourceHistoryRecord {
+  readonly intervalStartedAt: Date;
+  readonly used: number;
+  readonly reserved: number;
+
+  constructor({intervalStartedAt, used, reserved}: {intervalStartedAt: Date; used: number; reserved: number}) {
+    this.intervalStartedAt = intervalStartedAt;
+    this.used = used;
+    this.reserved = reserved;
+  }
+
+  total(): number {
+    return this.used + this.reserved;
+  }
+}
+
+export function resourceHistoryRecordFromJSON({
+  intervalStartedAt,
+  used,
+  reserved
+}: {
+  intervalStartedAt: string;
+  used: number;
+  reserved: number;
+}): ResourceHistoryRecord {
+  return new ResourceHistoryRecord({
+    intervalStartedAt: new Date(intervalStartedAt),
+    used,
+    reserved
+  });
+}

package/src/logic/utils.ts

@@ -0,0 +1,39 @@
+import _ from "lodash";
+
+export function timeSince(date: Date) {
+  const now = new Date();
+
+  const secondsPast = Math.floor((now.getTime() - date.getTime()) / 1000);
+
+  if (secondsPast < 60) {
+    return "<min";
+  }
+
+  const minutesPast = Math.floor(secondsPast / 60);
+
+  if (minutesPast < 60) {
+    return `${minutesPast}min`;
+  }
+
+  const hoursPast = Math.floor(minutesPast / 60);
+
+  if (hoursPast < 24) {
+    return `${hoursPast}h`;
+  }
+
+  const daysPast = Math.floor(hoursPast / 24);
+
+  if (daysPast < 30) {
+    return `${daysPast}d`;
+  }
+
+  const monthsPast = Math.floor(daysPast / 30);
+
+  if (monthsPast < 12) {
+    return `${monthsPast}m`;
+  }
+
+  const yearsPast = Math.floor(monthsPast / 12);
+
+  return `${yearsPast}y`;
+}

package/src/main.ts

@@ -0,0 +1,145 @@
+import {createApp} from "vue";
+import {createPinia} from "pinia";
+import * as Sentry from "@sentry/vue";
+
+import App from "./App.vue";
+import router from "./router";
+
+import FeedsList from "./components/FeedsList.vue";
+import EntriesList from "./components/EntriesList.vue";
+import RulesList from "./components/RulesList.vue";
+import TagsList from "./components/TagsList.vue";
+import ConfigSelector from "./components/ConfigSelector.vue";
+import ConfigFlag from "./components/ConfigFlag.vue";
+import EntryForList from "./components/EntryForList.vue";
+import RuleConstructor from "./components/RuleConstructor.vue";
+import RuleScoreUpdater from "./components/RuleScoreUpdater.vue";
+import TagsFilter from "./components/TagsFilter.vue";
+import TagsFilterElement from "./components/TagsFilterElement.vue";
+import DiscoveryForm from "./components/DiscoveryForm.vue";
+import FeedInfo from "./components/FeedInfo.vue";
+import EntryInfo from "./components/EntryInfo.vue";
+import OpmlUpload from "./components/OPMLUpload.vue";
+import FeedForList from "./components/FeedForList.vue";
+import SupertokensLogin from "./components/SupertokensLogin.vue";
+import FeedsCollections from "./components/FeedsCollections.vue";
+import FfunGithubButtons from "./components/FfunGithubButtons.vue";
+import FfunTag from "./components/FfunTag.vue";
+import SimplePagination from "./components/SimplePagination.vue";
+import UserSetting from "./components/UserSetting.vue";
+import OpenaiTokensUsage from "./components/OpenaiTokensUsage.vue";
+
+import ScoreSelector from "./inputs/ScoreSelector.vue";
+import InputMarker from "./inputs/Marker.vue";
+
+import ValueUrl from "./values/URL.vue";
+import ValueFeedId from "./values/FeedId.vue";
+import ValueDateTime from "./values/DateTime.vue";
+import ValueScore from "./values/Score.vue";
+
+import WideLayout from "./layouts/WideLayout.vue";
+import SidePanelLayout from "./layouts/SidePanelLayout.vue";
+
+import {useSupertokens} from "@/stores/supertokens";
+
+import VueCountdown from "@chenfengyuan/vue-countdown";
+import GithubButton from "vue-github-button";
+
+const app = createApp(App);
+
+app.component("FeedsList", FeedsList);
+app.component("EntriesList", EntriesList);
+app.component("RulesList", RulesList);
+app.component("TagsList", TagsList);
+app.component("ConfigSelector", ConfigSelector);
+app.component("ConfigFlag", ConfigFlag);
+app.component("EntryForList", EntryForList);
+app.component("RuleConstructor", RuleConstructor);
+app.component("RuleScoreUpdater", RuleScoreUpdater);
+app.component("TagsFilter", TagsFilter);
+app.component("TagsFilterElement", TagsFilterElement);
+app.component("DiscoveryForm", DiscoveryForm);
+app.component("FeedInfo", FeedInfo);
+app.component("EntryInfo", EntryInfo);
+app.component("OpmlUpload", OpmlUpload);
+app.component("FeedForList", FeedForList);
+app.component("SupertokensLogin", SupertokensLogin);
+app.component("FeedsCollections", FeedsCollections);
+app.component("FfunGithubButtons", FfunGithubButtons);
+app.component("FfunTag", FfunTag);
+app.component("SimplePagination", SimplePagination);
+app.component("UserSetting", UserSetting);
+app.component("OpenaiTokensUsage", OpenaiTokensUsage);
+
+app.component("ScoreSelector", ScoreSelector);
+app.component("InputMarker", InputMarker);
+
+app.component("ValueUrl", ValueUrl);
+app.component("ValueFeedId", ValueFeedId);
+app.component("ValueDateTime", ValueDateTime);
+app.component("ValueScore", ValueScore);
+
+app.component("WideLayout", WideLayout);
+app.component("SidePanelLayout", SidePanelLayout);
+
+app.component("vue-countdown", VueCountdown);
+app.component("github-button", GithubButton);
+
+app.use(createPinia());
+app.use(router);
+
+if (settings.sentryEnable) {
+  Sentry.init({
+    app,
+    dsn: settings.sentryDsn,
+    environment: settings.environment,
+    sampleRate: settings.sentrySampleRate,
+    attachStacktrace: true,
+    enableTracing: false,
+    integrations: []
+  });
+}
+
+app.mount("#app");
+
+import * as api from "@/logic/api";
+import * as settings from "@/logic/settings";
+
+// must be copy of smart_url from backend
+function smartUrl(domain: string, port: number) {
+  if (port == 80) {
+    return `http://${domain}`;
+  }
+
+  if (port == 443) {
+    return `https://${domain}`;
+  }
+
+  return `http://${domain}:${port}`;
+}
+
+let supertokens: ReturnType<typeof useSupertokens> | null = null;
+
+if (settings.authMode === settings.AuthMode.Supertokens) {
+  supertokens = useSupertokens();
+
+  supertokens.init({
+    apiDomain: smartUrl(settings.appDomain, settings.appPort),
+    apiBasePath: settings.authSupertokensApiBasePath,
+    appName: settings.appName,
+    resendAfter: settings.authSupertokensResendAfter
+  });
+} else if (settings.authMode === settings.AuthMode.SingleUser) {
+} else {
+  throw `Unknown auth mode: ${settings.authMode}`;
+}
+
+async function onSessionLost() {
+  if (supertokens !== null) {
+    await supertokens.logout();
+  }
+
+  router.push({name: "main", params: {}});
+}
+
+api.init({onSessionLost: onSessionLost});

package/src/router/index.ts

@@ -0,0 +1,61 @@
+import {createRouter, createWebHistory} from "vue-router";
+import MainView from "../views/MainView.vue";
+import AuthView from "../views/AuthView.vue";
+import FeedsView from "../views/FeedsView.vue";
+import NewsView from "../views/NewsView.vue";
+import RulesView from "../views/RulesView.vue";
+import DiscoveryView from "../views/DiscoveryView.vue";
+import CollectionsView from "../views/CollectionsView.vue";
+import SettingsView from "../views/SettingsView.vue";
+import * as e from "@/logic/enums";
+
+// lazy view loading does not work with router.push function
+// first attempt to router.push into not loaded view, will cause its loading, but will not change components
+
+const router = createRouter({
+  history: createWebHistory(import.meta.env.BASE_URL),
+  routes: [
+    {
+      path: "/",
+      name: "main",
+      component: MainView
+    },
+    {
+      path: "/auth",
+      name: "auth",
+      component: AuthView
+    },
+    {
+      path: "/feeds",
+      name: e.MainPanelMode.Feeds,
+      component: FeedsView
+    },
+    {
+      path: "/news",
+      name: e.MainPanelMode.Entries,
+      component: NewsView
+    },
+    {
+      path: "/rules",
+      name: e.MainPanelMode.Rules,
+      component: RulesView
+    },
+    {
+      path: "/discovery",
+      name: e.MainPanelMode.Discovery,
+      component: DiscoveryView
+    },
+    {
+      path: "/collections",
+      name: e.MainPanelMode.Collections,
+      component: CollectionsView
+    },
+    {
+      path: "/settings",
+      name: e.MainPanelMode.Settings,
+      component: SettingsView
+    }
+  ]
+});
+
+export default router;