refactor: remove useless stuff in Dockerfile

.adonisjs/api.ts

@@ -0,0 +1,467 @@
+import type { MakeTuyauRequest, MakeTuyauResponse } from '@tuyau/utils/types';
+import type { InferInput } from '@vinejs/vine/types';
+
+type UserThemePost = {
+	request: MakeTuyauRequest<
+		InferInput<
+			(typeof import('../app/validators/user.ts'))['updateUserThemeValidator']
+		>
+	>;
+	response: MakeTuyauResponse<
+		import('../app/controllers/apps_controller.ts').default['updateUserTheme']
+	>;
+};
+type FaviconGetHead = {
+	request: unknown;
+	response: MakeTuyauResponse<
+		import('../app/controllers/favicons_controller.ts').default['index']
+	>;
+};
+type SharedIdGetHead = {
+	request: MakeTuyauRequest<
+		InferInput<
+			(typeof import('../app/validators/shared_collection.ts'))['getSharedCollectionValidator']
+		>
+	>;
+	response: MakeTuyauResponse<
+		import('../app/controllers/shared_collections_controller.ts').default['index']
+	>;
+};
+type AdminGetHead = {
+	request: unknown;
+	response: MakeTuyauResponse<
+		import('../app/controllers/admin_controller.ts').default['index']
+	>;
+};
+type AuthLoginGetHead = {
+	request: unknown;
+	response: MakeTuyauResponse<
+		import('../app/controllers/users_controller.ts').default['login']
+	>;
+};
+type AuthCallbackGetHead = {
+	request: unknown;
+	response: MakeTuyauResponse<
+		import('../app/controllers/users_controller.ts').default['callbackAuth']
+	>;
+};
+type AuthLogoutGetHead = {
+	request: unknown;
+	response: MakeTuyauResponse<
+		import('../app/controllers/users_controller.ts').default['logout']
+	>;
+};
+type DashboardGetHead = {
+	request: unknown;
+	response: MakeTuyauResponse<
+		import('../app/controllers/collections_controller.ts').default['index']
+	>;
+};
+type CollectionsCreateGetHead = {
+	request: unknown;
+	response: MakeTuyauResponse<
+		import('../app/controllers/collections_controller.ts').default['showCreatePage']
+	>;
+};
+type CollectionsPost = {
+	request: MakeTuyauRequest<
+		InferInput<
+			(typeof import('../app/validators/collection.ts'))['createCollectionValidator']
+		>
+	>;
+	response: MakeTuyauResponse<
+		import('../app/controllers/collections_controller.ts').default['store']
+	>;
+};
+type CollectionsEditGetHead = {
+	request: unknown;
+	response: MakeTuyauResponse<
+		import('../app/controllers/collections_controller.ts').default['showEditPage']
+	>;
+};
+type CollectionsIdPut = {
+	request: MakeTuyauRequest<
+		InferInput<
+			(typeof import('../app/validators/collection.ts'))['updateCollectionValidator']
+		>
+	>;
+	response: MakeTuyauResponse<
+		import('../app/controllers/collections_controller.ts').default['update']
+	>;
+};
+type CollectionsDeleteGetHead = {
+	request: unknown;
+	response: MakeTuyauResponse<
+		import('../app/controllers/collections_controller.ts').default['showDeletePage']
+	>;
+};
+type CollectionsIdDelete = {
+	request: MakeTuyauRequest<
+		InferInput<
+			(typeof import('../app/validators/collection.ts'))['deleteCollectionValidator']
+		>
+	>;
+	response: MakeTuyauResponse<
+		import('../app/controllers/collections_controller.ts').default['delete']
+	>;
+};
+type LinksCreateGetHead = {
+	request: unknown;
+	response: MakeTuyauResponse<
+		import('../app/controllers/links_controller.ts').default['showCreatePage']
+	>;
+};
+type LinksPost = {
+	request: MakeTuyauRequest<
+		InferInput<
+			(typeof import('../app/validators/link.ts'))['createLinkValidator']
+		>
+	>;
+	response: MakeTuyauResponse<
+		import('../app/controllers/links_controller.ts').default['store']
+	>;
+};
+type LinksEditGetHead = {
+	request: unknown;
+	response: MakeTuyauResponse<
+		import('../app/controllers/links_controller.ts').default['showEditPage']
+	>;
+};
+type LinksIdPut = {
+	request: MakeTuyauRequest<
+		InferInput<
+			(typeof import('../app/validators/link.ts'))['updateLinkValidator']
+		>
+	>;
+	response: MakeTuyauResponse<
+		import('../app/controllers/links_controller.ts').default['update']
+	>;
+};
+type LinksIdFavoritePut = {
+	request: MakeTuyauRequest<
+		InferInput<
+			(typeof import('../app/validators/link.ts'))['updateLinkFavoriteStatusValidator']
+		>
+	>;
+	response: MakeTuyauResponse<
+		import('../app/controllers/links_controller.ts').default['toggleFavorite']
+	>;
+};
+type LinksDeleteGetHead = {
+	request: unknown;
+	response: MakeTuyauResponse<
+		import('../app/controllers/links_controller.ts').default['showDeletePage']
+	>;
+};
+type LinksIdDelete = {
+	request: MakeTuyauRequest<
+		InferInput<
+			(typeof import('../app/validators/link.ts'))['deleteLinkValidator']
+		>
+	>;
+	response: MakeTuyauResponse<
+		import('../app/controllers/links_controller.ts').default['delete']
+	>;
+};
+type SearchGetHead = {
+	request: MakeTuyauRequest<
+		InferInput<
+			(typeof import('../app/validators/search_term.ts'))['searchTermValidator']
+		>
+	>;
+	response: MakeTuyauResponse<
+		import('../app/controllers/searches_controller.ts').default['search']
+	>;
+};
+export interface ApiDefinition {
+	user: {
+		theme: {
+			$url: {};
+			$post: UserThemePost;
+		};
+	};
+	favicon: {
+		$url: {};
+		$get: FaviconGetHead;
+		$head: FaviconGetHead;
+	};
+	shared: {
+		':id': {
+			$url: {};
+			$get: SharedIdGetHead;
+			$head: SharedIdGetHead;
+		};
+	};
+	admin: {
+		$url: {};
+		$get: AdminGetHead;
+		$head: AdminGetHead;
+	};
+	auth: {
+		login: {
+			$url: {};
+			$get: AuthLoginGetHead;
+			$head: AuthLoginGetHead;
+		};
+		callback: {
+			$url: {};
+			$get: AuthCallbackGetHead;
+			$head: AuthCallbackGetHead;
+		};
+		logout: {
+			$url: {};
+			$get: AuthLogoutGetHead;
+			$head: AuthLogoutGetHead;
+		};
+	};
+	dashboard: {
+		$url: {};
+		$get: DashboardGetHead;
+		$head: DashboardGetHead;
+	};
+	collections: {
+		create: {
+			$url: {};
+			$get: CollectionsCreateGetHead;
+			$head: CollectionsCreateGetHead;
+		};
+		$url: {};
+		$post: CollectionsPost;
+		edit: {
+			$url: {};
+			$get: CollectionsEditGetHead;
+			$head: CollectionsEditGetHead;
+		};
+		':id': {
+			$url: {};
+			$put: CollectionsIdPut;
+			$delete: CollectionsIdDelete;
+		};
+		delete: {
+			$url: {};
+			$get: CollectionsDeleteGetHead;
+			$head: CollectionsDeleteGetHead;
+		};
+	};
+	links: {
+		create: {
+			$url: {};
+			$get: LinksCreateGetHead;
+			$head: LinksCreateGetHead;
+		};
+		$url: {};
+		$post: LinksPost;
+		edit: {
+			$url: {};
+			$get: LinksEditGetHead;
+			$head: LinksEditGetHead;
+		};
+		':id': {
+			$url: {};
+			$put: LinksIdPut;
+			favorite: {
+				$url: {};
+				$put: LinksIdFavoritePut;
+			};
+			$delete: LinksIdDelete;
+		};
+		delete: {
+			$url: {};
+			$get: LinksDeleteGetHead;
+			$head: LinksDeleteGetHead;
+		};
+	};
+	search: {
+		$url: {};
+		$get: SearchGetHead;
+		$head: SearchGetHead;
+	};
+}
+const routes = [
+	{
+		params: [],
+		name: 'home',
+		path: '/',
+		method: ['GET', 'HEAD'],
+		types: {} as unknown,
+	},
+	{
+		params: [],
+		name: 'terms',
+		path: '/terms',
+		method: ['GET', 'HEAD'],
+		types: {} as unknown,
+	},
+	{
+		params: [],
+		name: 'privacy',
+		path: '/privacy',
+		method: ['GET', 'HEAD'],
+		types: {} as unknown,
+	},
+	{
+		params: [],
+		name: 'user.theme',
+		path: '/user/theme',
+		method: ['POST'],
+		types: {} as UserThemePost,
+	},
+	{
+		params: [],
+		name: 'favicon',
+		path: '/favicon',
+		method: ['GET', 'HEAD'],
+		types: {} as FaviconGetHead,
+	},
+	{
+		params: ['id'],
+		name: 'shared',
+		path: '/shared/:id',
+		method: ['GET', 'HEAD'],
+		types: {} as SharedIdGetHead,
+	},
+	{
+		params: [],
+		name: 'admin.dashboard',
+		path: '/admin',
+		method: ['GET', 'HEAD'],
+		types: {} as AdminGetHead,
+	},
+	{
+		params: [],
+		name: 'auth.login',
+		path: '/auth/login',
+		method: ['GET', 'HEAD'],
+		types: {} as AuthLoginGetHead,
+	},
+	{
+		params: [],
+		name: 'auth.google',
+		path: '/auth/google',
+		method: ['GET', 'HEAD'],
+		types: {} as unknown,
+	},
+	{
+		params: [],
+		name: 'auth.callback',
+		path: '/auth/callback',
+		method: ['GET', 'HEAD'],
+		types: {} as AuthCallbackGetHead,
+	},
+	{
+		params: [],
+		name: 'auth.logout',
+		path: '/auth/logout',
+		method: ['GET', 'HEAD'],
+		types: {} as AuthLogoutGetHead,
+	},
+	{
+		params: [],
+		name: 'dashboard',
+		path: '/dashboard',
+		method: ['GET', 'HEAD'],
+		types: {} as DashboardGetHead,
+	},
+	{
+		params: [],
+		name: 'collection.create-form',
+		path: '/collections/create',
+		method: ['GET', 'HEAD'],
+		types: {} as CollectionsCreateGetHead,
+	},
+	{
+		params: [],
+		name: 'collection.create',
+		path: '/collections',
+		method: ['POST'],
+		types: {} as CollectionsPost,
+	},
+	{
+		params: [],
+		name: 'collection.edit-form',
+		path: '/collections/edit',
+		method: ['GET', 'HEAD'],
+		types: {} as CollectionsEditGetHead,
+	},
+	{
+		params: ['id'],
+		name: 'collection.edit',
+		path: '/collections/:id',
+		method: ['PUT'],
+		types: {} as CollectionsIdPut,
+	},
+	{
+		params: [],
+		name: 'collection.delete-form',
+		path: '/collections/delete',
+		method: ['GET', 'HEAD'],
+		types: {} as CollectionsDeleteGetHead,
+	},
+	{
+		params: ['id'],
+		name: 'collection.delete',
+		path: '/collections/:id',
+		method: ['DELETE'],
+		types: {} as CollectionsIdDelete,
+	},
+	{
+		params: [],
+		name: 'link.create-form',
+		path: '/links/create',
+		method: ['GET', 'HEAD'],
+		types: {} as LinksCreateGetHead,
+	},
+	{
+		params: [],
+		name: 'link.create',
+		path: '/links',
+		method: ['POST'],
+		types: {} as LinksPost,
+	},
+	{
+		params: [],
+		name: 'link.edit-form',
+		path: '/links/edit',
+		method: ['GET', 'HEAD'],
+		types: {} as LinksEditGetHead,
+	},
+	{
+		params: ['id'],
+		name: 'link.edit',
+		path: '/links/:id',
+		method: ['PUT'],
+		types: {} as LinksIdPut,
+	},
+	{
+		params: ['id'],
+		name: 'link.toggle-favorite',
+		path: '/links/:id/favorite',
+		method: ['PUT'],
+		types: {} as LinksIdFavoritePut,
+	},
+	{
+		params: [],
+		name: 'link.delete-form',
+		path: '/links/delete',
+		method: ['GET', 'HEAD'],
+		types: {} as LinksDeleteGetHead,
+	},
+	{
+		params: ['id'],
+		name: 'link.delete',
+		path: '/links/:id',
+		method: ['DELETE'],
+		types: {} as LinksIdDelete,
+	},
+	{
+		params: [],
+		name: 'search',
+		path: '/search',
+		method: ['GET', 'HEAD'],
+		types: {} as SearchGetHead,
+	},
+] as const;
+export const api = {
+	routes,
+	definition: {} as ApiDefinition,
+};

.babelrc

@@ -0,0 +1,3 @@
+{
+  "plugins": ["@emotion"]
+}

.vscode/extensions.json

@@ -1,3 +0,0 @@
-{
-	"recommendations": ["vunguyentuan.vscode-css-variables"]
-}

.vscode/settings.json

@@ -9,12 +9,5 @@
 		"*.js": "${capture}.js.map, ${capture}.min.js, ${capture}.d.ts",
 		"package.json": "pnpm-lock.yaml, tsconfig.json, eslint.config.js, .babelrc, vite.config.ts, .editorconfig",
 		"Makefile": "*compose.yml, Dockerfile, servers_pgadmin.json, .dockerignore"
-	},
+	}
-	"cssVariables.lookupFiles": [
-		"**/*.css",
-		"**/*.scss",
-		"**/*.sass",
-		"**/*.less",
-		"node_modules/@mantine/core/styles.css"
-	]
 }

CONTRIBUTING

@@ -1,61 +0,0 @@
-## Contributing to MyLinks
-
-First of all, thank you for considering contributing to MyLinks! We appreciate your time and efforts, and we want to make the contribution process as smooth and transparent as possible.
-
-### Table of Contents
-
-- [How to Contribute](#how-to-contribute)
-- [Code of Conduct](#code-of-conduct)
-- [Bug Reports and Feature Requests](#bug-reports-and-feature-requests)
-- [Pull Requests](#pull-requests)
-- [Development Setup](#development-setup)
-- [Community](#community)
-
-### How to Contribute
-
-There are several ways to contribute to MyLinks:
-- Reporting bugs
-- Suggesting new features
-- Improving the documentation
-- Writing or improving tests
-- Submitting code enhancements
-
-### Code of Conduct
-
-We are committed to fostering a welcoming community. Please review our [Code of Conduct](./CODE_OF_CONDUCT.md) to understand our expectations for all contributors.
-
-### Bug Reports and Feature Requests
-
-If you encounter any bugs or have ideas for new features, please create an issue in our [GitHub Issues](https://github.com/your-repo-url/issues). When reporting bugs, please provide:
-- A clear description of the problem.
-- Steps to reproduce the issue.
-- Any relevant log/error messages.
-
-For feature requests, please describe:
-- The problem you aim to solve.
-- How the feature could benefit users.
-
-### Pull Requests
-
-When making a pull request (PR), please adhere to the following guidelines:
-1. Fork the repository and create your branch from `main` (or the default branch).
-2. Run `pnpm run lint` and ensure your code passes the linter checks.
-3. Add tests for new features or bug fixes.
-4. Ensure your code passes existing tests (`pnpm run test`).
-5. Clearly describe the purpose of your pull request. Provide relevant issue numbers if applicable.
-
-To create a pull request:
-1. Push your branch to your forked repository.
-2. Submit a pull request (PR) to the `main` branch of MyLinks.
-
-> **Note:** All contributions are reviewed by maintainers. We may request changes or improvements before merging.
-
-### Development Setup
-
-For instructions on setting up your development environment, please refer to the [Getting Started](./README.md#getting-started) section in the `README.md`.
-
-### Community
-
-Feel free to join our community discussions on [our Trello board](https://trello.com/b/CwxkMeZp/mylinks) to collaborate on ideas, issues, and features!
-
-Thank you for helping make MyLinks better!

Dockerfile

@@ -1,57 +1,37 @@
 # Source : https://github.com/adonisjs-community/adonis-packages/blob/main/Dockerfile
 
-FROM node:22.11-alpine3.20 AS base
+FROM node:20-alpine3.18 as base
 
 RUN apk --no-cache add curl
 RUN corepack enable
 
 # All deps stage
-FROM base AS deps
+FROM base as deps
 WORKDIR /app
-ADD package.json pnpm-lock.yaml ./
+COPY package.json pnpm-lock.yaml /app/
+COPY .adonisjs /app/.adonisjs
 RUN pnpm install --ignore-scripts
 
 # Production only deps stage
-FROM base AS production-deps
+FROM base as production-deps
 WORKDIR /app
-ADD package.json pnpm-lock.yaml ./
+COPY package.json pnpm-lock.yaml /app/
+COPY .adonisjs /app/.adonisjs
 RUN pnpm install --ignore-scripts --prod
 
 # Build stage
-FROM base AS build
+FROM base as build
 WORKDIR /app
 COPY --from=deps /app/node_modules /app/node_modules
-ADD . .
+COPY . /app
-
-ENV PORT=3333
-ENV HOST=localhost
-ENV LOG_LEVEL=info
-ENV APP_KEY=sLoJth45JD1vcS8n92Y2JUd8w3OL4HQb
-ENV NODE_ENV=production
-ENV SESSION_DRIVER=cookie
-ENV DB_HOST=127.0.0.1
-ENV DB_PORT=5432
-ENV DB_USER=db_user
-ENV DB_PASSWORD=db_password
-ENV DB_DATABASE=db_db
-ENV GOOGLE_CLIENT_ID=client_id
-ENV GOOGLE_CLIENT_SECRET=client_secret
-ENV GOOGLE_CLIENT_CALLBACK_URL=http://localhost:3333/auth/callback
-
-RUN node ace izzy:routes
 RUN node ace build
 
 # Production stage
 FROM base
-
 ENV NODE_ENV=production
-ENV LOG_LEVEL=debug
-ENV CACHE_VIEWS=false
-ENV SESSION_DRIVER=cookie
-ENV PORT=$PORT
-
 WORKDIR /app
 COPY --from=production-deps /app/node_modules /app/node_modules
+COPY --from=production-deps /app/.adonisjs /app/.adonisjs
 COPY --from=build /app/build /app
 
 # Expose port
@@ -59,3 +39,4 @@ EXPOSE $PORT
 
 # Start app
 CMD node bin/console.js migration:run --force && node bin/server.js
+

LICENSE

@@ -1,674 +0,0 @@
-GNU GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-                            Preamble
-
-  The GNU General Public License is a free, copyleft license for
-software and other kinds of works.
-
-  The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works.  By contrast,
-the GNU General Public License is intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users.  We, the Free Software Foundation, use the
-GNU General Public License for most of our software; it applies also to
-any other work released this way by its authors.  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
-  To protect your rights, we need to prevent others from denying you
-these rights or asking you to surrender the rights.  Therefore, you have
-certain responsibilities if you distribute copies of the software, or if
-you modify it: responsibilities to respect the freedom of others.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must pass on to the recipients the same
-freedoms that you received.  You must make sure that they, too, receive
-or can get the source code.  And you must show them these terms so they
-know their rights.
-
-  Developers that use the GNU GPL protect your rights with two steps:
-(1) assert copyright on the software, and (2) offer you this License
-giving you legal permission to copy, distribute and/or modify it.
-
-  For the developers' and authors' protection, the GPL clearly explains
-that there is no warranty for this free software.  For both users' and
-authors' sake, the GPL requires that modified versions be marked as
-changed, so that their problems will not be attributed erroneously to
-authors of previous versions.
-
-  Some devices are designed to deny users access to install or run
-modified versions of the software inside them, although the manufacturer
-can do so.  This is fundamentally incompatible with the aim of
-protecting users' freedom to change the software.  The systematic
-pattern of such abuse occurs in the area of products for individuals to
-use, which is precisely where it is most unacceptable.  Therefore, we
-have designed this version of the GPL to prohibit the practice for those
-products.  If such problems arise substantially in other domains, we
-stand ready to extend this provision to those domains in future versions
-of the GPL, as needed to protect the freedom of users.
-
-  Finally, every program is threatened constantly by software patents.
-States should not allow patents to restrict development and use of
-software on general-purpose computers, but in those that do, we wish to
-avoid the special danger that patents applied to a free program could
-make it effectively proprietary.  To prevent this, the GPL assures that
-patents cannot be used to render the program non-free.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                       TERMS AND CONDITIONS
-
-  0. Definitions.
-
-  "This License" refers to version 3 of the GNU General Public License.
-
-  "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
-  "The Program" refers to any copyrightable work licensed under this
-License.  Each licensee is addressed as "you".  "Licensees" and
-"recipients" may be individuals or organizations.
-
-  To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy.  The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
-  A "covered work" means either the unmodified Program or a work based
-on the Program.
-
-  To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy.  Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
-  To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies.  Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
-  An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License.  If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
-  1. Source Code.
-
-  The "source code" for a work means the preferred form of the work
-for making modifications to it.  "Object code" means any non-source
-form of a work.
-
-  A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
-  The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form.  A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
-  The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities.  However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work.  For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
-  The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
-  The Corresponding Source for a work in source code form is that
-same work.
-
-  2. Basic Permissions.
-
-  All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met.  This License explicitly affirms your unlimited
-permission to run the unmodified Program.  The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work.  This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
-  You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force.  You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright.  Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
-  Conveying under any other circumstances is permitted solely under
-the conditions stated below.  Sublicensing is not allowed; section 10
-makes it unnecessary.
-
-  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
-  No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
-  When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
-  4. Conveying Verbatim Copies.
-
-  You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
-  You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
-  5. Conveying Modified Source Versions.
-
-  You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
-    a) The work must carry prominent notices stating that you modified
-    it, and giving a relevant date.
-
-    b) The work must carry prominent notices stating that it is
-    released under this License and any conditions added under section
-    7.  This requirement modifies the requirement in section 4 to
-    "keep intact all notices".
-
-    c) You must license the entire work, as a whole, under this
-    License to anyone who comes into possession of a copy.  This
-    License will therefore apply, along with any applicable section 7
-    additional terms, to the whole of the work, and all its parts,
-    regardless of how they are packaged.  This License gives no
-    permission to license the work in any other way, but it does not
-    invalidate such permission if you have separately received it.
-
-    d) If the work has interactive user interfaces, each must display
-    Appropriate Legal Notices; however, if the Program has interactive
-    interfaces that do not display Appropriate Legal Notices, your
-    work need not make them do so.
-
-  A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit.  Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
-  6. Conveying Non-Source Forms.
-
-  You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
-    a) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by the
-    Corresponding Source fixed on a durable physical medium
-    customarily used for software interchange.
-
-    b) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by a
-    written offer, valid for at least three years and valid for as
-    long as you offer spare parts or customer support for that product
-    model, to give anyone who possesses the object code either (1) a
-    copy of the Corresponding Source for all the software in the
-    product that is covered by this License, on a durable physical
-    medium customarily used for software interchange, for a price no
-    more than your reasonable cost of physically performing this
-    conveying of source, or (2) access to copy the
-    Corresponding Source from a network server at no charge.
-
-    c) Convey individual copies of the object code with a copy of the
-    written offer to provide the Corresponding Source.  This
-    alternative is allowed only occasionally and noncommercially, and
-    only if you received the object code with such an offer, in accord
-    with subsection 6b.
-
-    d) Convey the object code by offering access from a designated
-    place (gratis or for a charge), and offer equivalent access to the
-    Corresponding Source in the same way through the same place at no
-    further charge.  You need not require recipients to copy the
-    Corresponding Source along with the object code.  If the place to
-    copy the object code is a network server, the Corresponding Source
-    may be on a different server (operated by you or a third party)
-    that supports equivalent copying facilities, provided you maintain
-    clear directions next to the object code saying where to find the
-    Corresponding Source.  Regardless of what server hosts the
-    Corresponding Source, you remain obligated to ensure that it is
-    available for as long as needed to satisfy these requirements.
-
-    e) Convey the object code using peer-to-peer transmission, provided
-    you inform other peers where the object code and Corresponding
-    Source of the work are being offered to the general public at no
-    charge under subsection 6d.
-
-  A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
-  A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling.  In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage.  For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product.  A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
-  "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source.  The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
-  If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information.  But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
-  The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed.  Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
-  Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
-  7. Additional Terms.
-
-  "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law.  If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
-  When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it.  (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.)  You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
-  Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
-    a) Disclaiming warranty or limiting liability differently from the
-    terms of sections 15 and 16 of this License; or
-
-    b) Requiring preservation of specified reasonable legal notices or
-    author attributions in that material or in the Appropriate Legal
-    Notices displayed by works containing it; or
-
-    c) Prohibiting misrepresentation of the origin of that material, or
-    requiring that modified versions of such material be marked in
-    reasonable ways as different from the original version; or
-
-    d) Limiting the use for publicity purposes of names of licensors or
-    authors of the material; or
-
-    e) Declining to grant rights under trademark law for use of some
-    trade names, trademarks, or service marks; or
-
-    f) Requiring indemnification of licensors and authors of that
-    material by anyone who conveys the material (or modified versions of
-    it) with contractual assumptions of liability to the recipient, for
-    any liability that these contractual assumptions directly impose on
-    those licensors and authors.
-
-  All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10.  If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term.  If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
-  If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
-  Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
-  8. Termination.
-
-  You may not propagate or modify a covered work except as expressly
-provided under this License.  Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
-  However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
-  Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
-  Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License.  If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
-  9. Acceptance Not Required for Having Copies.
-
-  You are not required to accept this License in order to receive or
-run a copy of the Program.  Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance.  However,
-nothing other than this License grants you permission to propagate or
-modify any covered work.  These actions infringe copyright if you do
-not accept this License.  Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
-  10. Automatic Licensing of Downstream Recipients.
-
-  Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License.  You are not responsible
-for enforcing compliance by third parties with this License.
-
-  An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations.  If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
-  You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License.  For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
-  11. Patents.
-
-  A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based.  The
-work thus licensed is called the contributor's "contributor version".
-
-  A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version.  For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
-  Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
-  In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement).  To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
-  If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients.  "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
-  If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
-  A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License.  You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
-  Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
-  12. No Surrender of Others' Freedom.
-
-  If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all.  For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
-  13. Use with the GNU Affero General Public License.
-
-  Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU Affero General Public License into a single
-combined work, and to convey the resulting work.  The terms of this
-License will continue to apply to the part which is the covered work,
-but the special requirements of the GNU Affero General Public License,
-section 13, concerning interaction through a network will apply to the
-combination as such.
-
-  14. Revised Versions of this License.
-
-  The Free Software Foundation may publish revised and/or new versions of
-the GNU General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-  Each version is given a distinguishing version number.  If the
-Program specifies that a certain numbered version of the GNU General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation.  If the Program does not specify a version number of the
-GNU General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
-  If the Program specifies that a proxy can decide which future
-versions of the GNU General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
-  Later license versions may give you additional or different
-permissions.  However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
-  15. Disclaimer of Warranty.
-
-  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. Limitation of Liability.
-
-  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
-  17. Interpretation of Sections 15 and 16.
-
-  If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
-                     END OF TERMS AND CONDITIONS
-
-            How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
-  If the program does terminal interaction, make it output a short
-notice like this when it starts in an interactive mode:
-
-    <program>  Copyright (C) <year>  <name of author>
-    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, your program's commands
-might be different; for a GUI interface, you would use an "about box".
-
-  You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU GPL, see
-<https://www.gnu.org/licenses/>.
-
-  The GNU General Public License does not permit incorporating your program
-into proprietary programs.  If your program is a subroutine library, you
-may consider it more useful to permit linking proprietary applications with
-the library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.  But first, please read
-<https://www.gnu.org/licenses/why-not-lgpl.html>.

README.md

@@ -1,59 +1,25 @@
-![](./docs//imgs/ml_dashboard_dark.png)
+# MyLinks
 
-<div align="center">
+MyLinks is a tool that lets you manage your favorite links in an intuitive interface.
-  <h1>MyLinks</h1>
+Free and open source software, focused on privacy and self-hosting.
-  <p>Another bookmark manager that lets you manage and share<br>your favorite links in an intuitive interface</p>
-  <p>
-    <a href="https://github.com/my-links/my-links/issues"><img src="https://img.shields.io/github/issues/my-links/my-links.svg" alt="GitHub Issues"></a>
-    <a href="https://github.com/my-links/my-links/blob/main/LICENSE"><img src="https://img.shields.io/github/license/my-links/my-links.svg" alt="License"></a>
-    <a href="https://trello.com/b/CwxkMeZp/mylinks"><img src="https://img.shields.io/badge/roadmap-Trello-blue" alt="Project Roadmap"></a>
-  </p>
-</div>
 
-## Table of Contents
+# Setup
 
-- [Main Features](#main-features)
+Copy `example.env` file as `.env` and edit the properties.
-- [Getting Started](#getting-started)
-  - [Setup](#setup)
-  - [Development](#development)
-    - [Using Docker](#docker)
-    - [Using PNPM](#pnpm)
-  - [Production](#start-as-prod)
-- [Configuration](#configuration)
-  - [Generate app_key](#generate_app_key)
-  - [GitHub Actions](#github-actions)
-- [Contributing](#contributing)
-- [License](#license)
 
-## Main Features
+```
-
-- **Organize bookmarks with collections**: Keep your links tidy and easily accessible by grouping them into customizable collections.
-- **Intuitive link management**: Add, edit, and manage your bookmarks effortlessly with a user-friendly interface.
-- **Powerful search functionality**: Quickly locate any bookmark using the robust search feature, enhancing your productivity.
-- **Privacy-focused and open-source**: Enjoy a secure, transparent experience with an open-source platform that prioritizes your privacy.
-- **Browser extension (coming soon)**: Seamlessly integrate MyLinks into your browsing experience with the upcoming official browser extension.
-- **Shareable collections**: Easily share your curated collections with others, facilitating collaboration and information sharing.
-- **Community-driven development**: Contribute to MyLinks by suggesting improvements and features, helping to shape the tool to better meet user needs.
-
-## Getting Started
-
-### Setup
-
-Copy the `example.env` file to `.env` and edit the properties:
-
-```bash
 cp example.env .env
 ```
 
-### Development
+## Development
 
-#### Docker
+### Docker
 
 ```shell
 make dev
 ```
 
-#### PNPM
+### PNPM
 
 ```shell
 # reset database and (force) apply all migrations
@@ -62,15 +28,15 @@ node ace migration:fresh
 pnpm run dev
 ```
 
-### Start as prod
+## Start as prod
 
-#### Docker
+### Docker
 
 ```shell
 make prod
 ```
 
-#### PNPM
+### PNPM
 
 ```shell
 # create production build
@@ -83,16 +49,14 @@ cp ../.env .
 pnpm run start
 ```
 
-## Configuration
+## Generate app_key
-
-### Generate app_key
 
 ```shell
 # generate a random app key
 openssl rand -base64 32
 ```
 
-### GitHub Actions
+## GitHub Actions
 
 Env var to define :
 
@@ -123,16 +87,3 @@ ssh-copy-id -i ./id_rsa.pub user@host
 ```
 
 > Source: https://github.com/appleboy/ssh-action#setting-up-a-ssh-key
-
-## Contributing
-
-We welcome contributions! Please visit our Trello board for project management and roadmap details. You can contribute by:
-
-- Creating issues for bugs, features, or discussions.
-- Submitting pull requests (PRs) with bug fixes, new features, or documentation updates.
-
-For detailed contribution guidelines, refer to the CONTRIBUTING.md file.
-
-## License
-
-This project is licensed under the [GPLv3 License](./LICENCE).

adonisrc.ts

@@ -2,29 +2,29 @@ import { defineConfig } from '@adonisjs/core/app';
 
 export default defineConfig({
 	/*
-  |--------------------------------------------------------------------------
+|--------------------------------------------------------------------------
-  | Commands
+| Commands
-  |--------------------------------------------------------------------------
+|--------------------------------------------------------------------------
-  |
+|
-  | List of ace commands to register from packages. The application commands
+| List of ace commands to register from packages. The application commands
-  | will be scanned automatically from the "./commands" directory.
+| will be scanned automatically from the "./commands" directory.
-  |
+|
-  */
+*/
 	commands: [
 		() => import('@adonisjs/core/commands'),
 		() => import('@adonisjs/lucid/commands'),
-		() => import('@izzyjs/route/commands'),
+		() => import('@tuyau/core/commands'),
 	],
 
 	/*
-  |--------------------------------------------------------------------------
+|--------------------------------------------------------------------------
-  | Service providers
+| Service providers
-  |--------------------------------------------------------------------------
+|--------------------------------------------------------------------------
-  |
+|
-  | List of service providers to import and register when booting the
+| List of service providers to import and register when booting the
-  | application
+| application
-  |
+|
-  */
+*/
 	providers: [
 		() => import('@adonisjs/core/providers/app_provider'),
 		() => import('@adonisjs/core/providers/hash_provider'),
@@ -43,29 +43,29 @@ export default defineConfig({
 		() => import('@adonisjs/auth/auth_provider'),
 		() => import('@adonisjs/inertia/inertia_provider'),
 		() => import('@adonisjs/ally/ally_provider'),
-		() => import('@izzyjs/route/izzy_provider'),
 		() => import('#providers/route_provider'),
+		() => import('@tuyau/core/tuyau_provider'),
 	],
 
 	/*
-  |--------------------------------------------------------------------------
+|--------------------------------------------------------------------------
-  | Preloads
+| Preloads
-  |--------------------------------------------------------------------------
+|--------------------------------------------------------------------------
-  |
+|
-  | List of modules to import before starting the application.
+| List of modules to import before starting the application.
-  |
+|
-  */
+*/
 	preloads: [() => import('#start/routes'), () => import('#start/kernel')],
 
 	/*
-  |--------------------------------------------------------------------------
+|--------------------------------------------------------------------------
-  | Tests
+| Tests
-  |--------------------------------------------------------------------------
+|--------------------------------------------------------------------------
-  |
+|
-  | List of test suites to organize tests by their type. Feel free to remove
+| List of test suites to organize tests by their type. Feel free to remove
-  | and add additional suites.
+| and add additional suites.
-  |
+|
-  */
+*/
 	tests: {
 		suites: [
 			{
@@ -83,14 +83,14 @@ export default defineConfig({
 	},
 
 	/*
-  |--------------------------------------------------------------------------
+|--------------------------------------------------------------------------
-  | Metafiles
+| Metafiles
-  |--------------------------------------------------------------------------
+|--------------------------------------------------------------------------
-  |
+|
-  | A collection of files you want to copy to the build folder when creating
+| A collection of files you want to copy to the build folder when creating
-  | the production build.
+| the production build.
-  |
+|
-  */
+*/
 	metaFiles: [
 		{
 			pattern: 'resources/views/**/*.edge',
@@ -105,6 +105,5 @@ export default defineConfig({
 	assetsBundler: false,
 	unstable_assembler: {
 		onBuildStarting: [() => import('@adonisjs/vite/build_hook')],
-		onDevServerStarted: [() => import('@izzyjs/route/dev_hook')],
 	},
 });

app/admin/routes/routes.ts

@@ -1 +0,0 @@
-import './admin_routes.js';

app/auth/routes/routes.ts

@@ -1 +0,0 @@
-import './auth_routes.js';

app/collections/routes/routes.ts

@@ -1 +0,0 @@
-import './collections_routes.js';

app/collections/validators/delete_collection_validator.ts

@@ -1,8 +0,0 @@
-import { params } from '#core/validators/params_object';
-import vine from '@vinejs/vine';
-
-export const deleteCollectionValidator = vine.compile(
-	vine.object({
-		params,
-	})
-);

app/collections/validators/update_collection_validator.ts

@@ -1,14 +0,0 @@
-import { Visibility } from '#collections/enums/visibility';
-import { params } from '#core/validators/params_object';
-import vine from '@vinejs/vine';
-
-export const updateCollectionValidator = vine.compile(
-	vine.object({
-		name: vine.string().trim().minLength(1).maxLength(254),
-		description: vine.string().trim().maxLength(254).nullable(),
-		visibility: vine.enum(Visibility),
-		nextId: vine.number().optional(),
-
-		params,
-	})
-);

app/constants/paths.ts

@@ -1,6 +1,6 @@
 const PATHS = {
-	AUTHOR: 'https://www.sonny.dev/?utm_source=mylinks',
+	AUTHOR: 'https://www.sonny.dev/',
-	REPO_GITHUB: 'https://github.com/my-links/my-links',
+	REPO_GITHUB: 'https://github.com/Sonny93/my-links',
 	EXTENSION:
 		'https://chromewebstore.google.com/detail/mylinks/agkmlplihacolkakgeccnbhphnepphma',
 } as const;

app/constants/session.ts

@@ -0,0 +1,2 @@
+export const PREFER_DARK_THEME = 'prefer_dark_theme';
+export const DARK_THEME_DEFAULT_VALUE = true;

app/controllers/admin_controller.ts

@@ -1,9 +1,9 @@
-import AuthController from '#auth/controllers/auth_controller';
+import CollectionsController from '#controllers/collections_controller';
-import CollectionsController from '#collections/controllers/collections_controller';
+import LinksController from '#controllers/links_controller';
-import LinksController from '#links/controllers/links_controller';
+import UsersController from '#controllers/users_controller';
-import User from '#user/models/user';
+import User from '#models/user';
 import { inject } from '@adonisjs/core';
-import { HttpContext } from '@adonisjs/core/http';
+import type { HttpContext } from '@adonisjs/core/http';
 
 class UserWithRelationCountDto {
 	constructor(private user: User) {}
@@ -26,7 +26,7 @@ class UserWithRelationCountDto {
 @inject()
 export default class AdminController {
 	constructor(
-		protected usersController: AuthController,
+		protected usersController: UsersController,
 		protected linksController: LinksController,
 		protected collectionsController: CollectionsController
 	) {}

app/controllers/apps_controller.ts

@@ -0,0 +1,13 @@
+import { PREFER_DARK_THEME } from '#constants/session';
+import { updateUserThemeValidator } from '#validators/user';
+import type { HttpContext } from '@adonisjs/core/http';
+
+export default class AppsController {
+	async updateUserTheme({ request, session, response }: HttpContext) {
+		const { preferDarkTheme } = await request.validateUsing(
+			updateUserThemeValidator
+		);
+		session.put(PREFER_DARK_THEME, preferDarkTheme);
+		return response.ok({ message: 'ok' });
+	}
+}

app/controllers/collections_controller.ts

@@ -1,8 +1,10 @@
-import Collection from '#collections/models/collection';
+import Collection from '#models/collection';
-import { createCollectionValidator } from '#collections/validators/create_collection_validator';
+import User from '#models/user';
-import { deleteCollectionValidator } from '#collections/validators/delete_collection_validator';
+import {
-import { updateCollectionValidator } from '#collections/validators/update_collection_validator';
+	createCollectionValidator,
-import User from '#user/models/user';
+	deleteCollectionValidator,
+	updateCollectionValidator,
+} from '#validators/collection';
 import type { HttpContext } from '@adonisjs/core/http';
 import db from '@adonisjs/lucid/services/db';
 

app/controllers/favicons_controller.ts

@@ -1,9 +1,17 @@
-import FaviconNotFoundException from '#favicons/exceptions/favicon_not_found_exception';
+import FaviconNotFoundException from '#exceptions/favicon_not_found_exception';
-import { Favicon } from '#favicons/types/favicon_type';
+import { cache } from '#lib/cache';
+import type { HttpContext } from '@adonisjs/core/http';
 import logger from '@adonisjs/core/services/logger';
 import { parse } from 'node-html-parser';
 
-export class FaviconService {
+interface Favicon {
+	buffer: Buffer;
+	url: string;
+	type: string;
+	size: number;
+}
+
+export default class FaviconsController {
 	private userAgent =
 		'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36 Edg/119.0.0.0';
 	private relList = [
@@ -16,11 +24,27 @@ export class FaviconService {
 		'fluid-icon',
 	];
 
-	async getFavicon(url: string): Promise<Favicon> {
+	async index(ctx: HttpContext) {
+		const url = ctx.request.qs()?.url;
+		if (!url) {
+			throw new Error('Missing URL');
+		}
+
+		const cacheNs = cache.namespace('favicon');
+		const favicon = await cacheNs.getOrSet({
+			key: url,
+			ttl: '1h',
+			factory: () => this.tryGetFavicon(url),
+		});
+		return this.sendImage(ctx, favicon);
+	}
+
+	private async tryGetFavicon(url: string): Promise<Favicon> {
+		const faviconUrl = this.buildFaviconUrl(url, '/favicon.ico');
 		try {
-			return await this.fetchFavicon(this.buildFaviconUrl(url, '/favicon.ico'));
+			return await this.fetchFavicon(faviconUrl);
 		} catch {
-			logger.debug(`Unable to retrieve favicon from ${url}/favicon.ico`);
+			logger.debug(`Unable to retrieve favicon from ${faviconUrl}`);
 		}
 
 		const documentText = await this.fetchDocumentText(url);
@@ -30,7 +54,15 @@ export class FaviconService {
 			throw new FaviconNotFoundException(`No favicon path found in ${url}`);
 		}
 
-		return await this.fetchFaviconFromPath(url, faviconPath);
+		if (faviconPath.startsWith('http')) {
+			try {
+				return await this.fetchFavicon(faviconPath);
+			} catch {
+				logger.debug(`Unable to retrieve favicon from ${faviconPath}`);
+			}
+		}
+
+		return this.fetchFaviconFromPath(url, faviconPath);
 	}
 
 	private async fetchFavicon(url: string): Promise<Favicon> {
@@ -95,9 +127,7 @@ export class FaviconService {
 
 		const basePath = this.urlWithoutSearchParams(base);
 		const baseUrl = basePath.endsWith('/') ? basePath.slice(0, -1) : basePath;
-		const finalUrl = `${baseUrl}/${path}`;
+		return `${baseUrl}/${path}`;
-		logger.debug(`Built favicon URL: ${finalUrl}`);
-		return finalUrl;
 	}
 
 	private urlWithoutSearchParams(url: string): string {
@@ -121,4 +151,10 @@ export class FaviconService {
 		const headers = new Headers({ 'User-Agent': this.userAgent });
 		return fetch(url, { headers });
 	}
+
+	private sendImage(ctx: HttpContext, { buffer, type, size }: Favicon) {
+		ctx.response.header('Content-Type', type);
+		ctx.response.header('Content-Length', size.toString());
+		ctx.response.send(buffer, true);
+	}
 }

app/controllers/links_controller.ts

@@ -1,11 +1,13 @@
-import CollectionsController from '#collections/controllers/collections_controller';
+import CollectionsController from '#controllers/collections_controller';
-import Link from '#links/models/link';
+import Link from '#models/link';
-import { createLinkValidator } from '#links/validators/create_link_validator';
+import {
-import { deleteLinkValidator } from '#links/validators/delete_link_validator';
+	createLinkValidator,
-import { updateLinkFavoriteStatusValidator } from '#links/validators/update_favorite_link_validator';
+	deleteLinkValidator,
-import { updateLinkValidator } from '#links/validators/update_link_validator';
+	updateLinkFavoriteStatusValidator,
+	updateLinkValidator,
+} from '#validators/link';
 import { inject } from '@adonisjs/core';
-import { HttpContext } from '@adonisjs/core/http';
+import type { HttpContext } from '@adonisjs/core/http';
 import db from '@adonisjs/lucid/services/db';
 
 @inject()

app/controllers/searches_controller.ts

@@ -1,16 +1,12 @@
+import { searchTermValidator } from '#validators/search_term';
 import type { HttpContext } from '@adonisjs/core/http';
 import db from '@adonisjs/lucid/services/db';
 
-export default class SearchController {
+export default class SearchesController {
 	async search({ request, auth }: HttpContext) {
-		const term = request.qs()?.term;
+		const { searchTerm } = await request.validateUsing(searchTermValidator);
-		if (!term) {
-			console.warn('qs term null');
-			return { error: 'missing "term" query param' };
-		}
-
 		const { rows } = await db.rawQuery('SELECT * FROM search_text(?, ?)', [
-			term,
+			searchTerm,
 			auth.user!.id,
 		]);
 		return { results: rows };

app/controllers/shared_collections_controller.ts

@@ -0,0 +1,24 @@
+import { Visibility } from '#enums/visibility';
+import Collection from '#models/collection';
+import { getSharedCollectionValidator } from '#validators/shared_collection';
+import type { HttpContext } from '@adonisjs/core/http';
+
+export default class SharedCollectionsController {
+	async index({ request, inertia }: HttpContext) {
+		const { params } = await request.validateUsing(
+			getSharedCollectionValidator
+		);
+
+		const collection = await this.getSharedCollectionById(params.id);
+		return inertia.render('shared', { collection });
+	}
+
+	private async getSharedCollectionById(id: Collection['id']) {
+		return await Collection.query()
+			.where('id', id)
+			.andWhere('visibility', Visibility.PUBLIC)
+			.preload('links')
+			.preload('author')
+			.firstOrFail();
+	}
+}

app/controllers/users_controller.ts

@@ -1,11 +1,11 @@
-import User from '#user/models/user';
+import User from '#models/user';
+import { RouteName } from '#types/tuyau';
 import type { HttpContext } from '@adonisjs/core/http';
 import logger from '@adonisjs/core/services/logger';
 import db from '@adonisjs/lucid/services/db';
-import { RouteName } from '@izzyjs/route/types';
 
-export default class AuthController {
+export default class UsersController {
-	private redirectTo: RouteName = 'auth';
+	private redirectTo: RouteName = 'auth.login';
 
 	login({ inertia }: HttpContext) {
 		return inertia.render('login');
@@ -67,7 +67,7 @@ export default class AuthController {
 		await auth.use('web').logout();
 		session.flash('flash', 'Successfully disconnected');
 		logger.info(`[${auth.user?.email}] disconnected successfully`);
-		response.redirect('/');
+		response.redirectToNamedRoute(this.redirectTo);
 	}
 
 	async getAllUsersWithTotalRelations() {

app/core/middlewares/service_worker_scope_extender.ts

@@ -1,18 +0,0 @@
-import { HttpContext } from '@adonisjs/core/http';
-
-const HEADER_NAME = 'Service-Worker-Allowed';
-
-export default class ServiceWorkerScopeExtender {
-	async handle(
-		{ request, response, logger }: HttpContext,
-		next: () => Promise<void>
-	) {
-		if (request.url().startsWith('/assets/sw.js')) {
-			response.header(HEADER_NAME, '/');
-			logger.debug(
-				`Header ${HEADER_NAME} for ${request.url()} set to ${response.getHeader(HEADER_NAME)}`
-			);
-		}
-		await next();
-	}
-}

app/core/validators/params_object.ts

@@ -1,5 +0,0 @@
-import vine from '@vinejs/vine';
-
-export const params = vine.object({
-	id: vine.number(),
-});

app/favicons/controllers/favicons_controller.ts

@@ -1,34 +0,0 @@
-import { CacheService } from '#favicons/services/cache_service';
-import { FaviconService } from '#favicons/services/favicons_service';
-import { Favicon } from '#favicons/types/favicon_type';
-import { inject } from '@adonisjs/core';
-import type { HttpContext } from '@adonisjs/core/http';
-
-@inject()
-export default class FaviconsController {
-	private faviconService: FaviconService;
-	private cacheService: CacheService;
-
-	constructor(faviconService: FaviconService, cacheService: CacheService) {
-		this.faviconService = faviconService;
-		this.cacheService = cacheService;
-	}
-
-	async index(ctx: HttpContext) {
-		const url = ctx.request.qs()?.url;
-		if (!url) {
-			throw new Error('Missing URL');
-		}
-
-		const favicon = await this.cacheService.getOrSetFavicon(url, () =>
-			this.faviconService.getFavicon(url)
-		);
-		return this.sendImage(ctx, favicon);
-	}
-
-	private sendImage(ctx: HttpContext, { buffer, type, size }: Favicon) {
-		ctx.response.header('Content-Type', type);
-		ctx.response.header('Content-Length', size.toString());
-		ctx.response.send(buffer, true);
-	}
-}

app/favicons/routes/routes.ts

@@ -1 +0,0 @@
-import './favicons_routes.js';

app/favicons/services/cache_service.ts

@@ -1,17 +0,0 @@
-import { cache } from '#core/lib/cache';
-import { Favicon } from '#favicons/types/favicon_type';
-
-export class CacheService {
-	private cacheNs = cache.namespace('favicon');
-
-	async getOrSetFavicon(
-		url: string,
-		factory: () => Promise<Favicon>
-	): Promise<Favicon> {
-		return this.cacheNs.getOrSet({
-			key: url,
-			ttl: '1h',
-			factory,
-		});
-	}
-}

app/favicons/types/favicon_type.ts

@@ -1,6 +0,0 @@
-export type Favicon = {
-	buffer: Buffer;
-	url: string;
-	type: string;
-	size: number;
-};

app/home/routes/home_routes.ts

@@ -1,3 +0,0 @@
-import router from '@adonisjs/core/services/router';
-
-router.on('/').renderInertia('home').as('home');

app/home/routes/routes.ts

@@ -1 +0,0 @@
-import './home_routes.js';

app/legal/routes/legal_routes.ts

@@ -1,4 +0,0 @@
-import router from '@adonisjs/core/services/router';
-
-router.on('/terms').renderInertia('terms').as('terms');
-router.on('/privacy').renderInertia('privacy').as('privacy');

app/legal/routes/routes.ts

@@ -1 +0,0 @@
-import './legal_routes.js';

app/lib/tuyau.ts

@@ -0,0 +1,22 @@
+import { api } from '#adonisjs/api';
+import { QueryParams } from '#types/query_params';
+import { RouteName } from '#types/tuyau';
+
+export const getRoute = (routeName: RouteName, options?: QueryParams) => {
+	const current = api.routes.find((route) => route.name === routeName);
+	if (!current) {
+		throw new Error(`Route ${routeName} not found`);
+	}
+
+	if (options?.qs) {
+		const searchParams = new URLSearchParams(options?.qs);
+		return { ...current, path: `${current.path}?${searchParams.toString()}` };
+	}
+
+	return current;
+};
+
+export function getPath(routeName: RouteName, options?: QueryParams) {
+	const current = getRoute(routeName, options);
+	return current.path;
+}

app/links/routes/routes.ts

@@ -1 +0,0 @@
-import './links_routes.js';

app/links/validators/create_link_validator.ts

@@ -1,11 +0,0 @@
-import vine from '@vinejs/vine';
-
-export const createLinkValidator = vine.compile(
-	vine.object({
-		name: vine.string().trim().minLength(1).maxLength(254),
-		description: vine.string().trim().maxLength(300).optional(),
-		url: vine.string().trim(),
-		favorite: vine.boolean(),
-		collectionId: vine.number(),
-	})
-);

app/links/validators/delete_link_validator.ts

@@ -1,8 +0,0 @@
-import { params } from '#core/validators/params_object';
-import vine from '@vinejs/vine';
-
-export const deleteLinkValidator = vine.compile(
-	vine.object({
-		params,
-	})
-);

app/links/validators/update_favorite_link_validator.ts

@@ -1,10 +0,0 @@
-import { params } from '#core/validators/params_object';
-import vine from '@vinejs/vine';
-
-export const updateLinkFavoriteStatusValidator = vine.compile(
-	vine.object({
-		favorite: vine.boolean(),
-
-		params,
-	})
-);

app/links/validators/update_link_validator.ts

@@ -1,14 +0,0 @@
-import { params } from '#core/validators/params_object';
-import vine from '@vinejs/vine';
-
-export const updateLinkValidator = vine.compile(
-	vine.object({
-		name: vine.string().trim().minLength(1).maxLength(254),
-		description: vine.string().trim().maxLength(300).optional(),
-		url: vine.string().trim(),
-		favorite: vine.boolean(),
-		collectionId: vine.number(),
-
-		params,
-	})
-);

app/middleware/auth_middleware.ts

@@ -1,7 +1,7 @@
+import { getPath } from '#lib/tuyau';
 import type { Authenticators } from '@adonisjs/auth/types';
 import type { HttpContext } from '@adonisjs/core/http';
 import type { NextFn } from '@adonisjs/core/types/http';
-import { route } from '@izzyjs/route/client';
 
 /**
  * Auth middleware is used authenticate HTTP requests and deny
@@ -11,7 +11,7 @@ export default class AuthMiddleware {
 	/**
 	 * The URL to redirect to, when authentication fails
 	 */
-	redirectTo = route('auth').path;
+	redirectTo = getPath('auth.login');
 
 	async handle(
 		ctx: HttpContext,

app/models/collection.ts

@@ -1,9 +1,9 @@
-import { Visibility } from '#collections/enums/visibility';
+import AppBaseModel from '#models/app_base_model';
-import AppBaseModel from '#core/models/app_base_model';
+import Link from '#models/link';
-import Link from '#links/models/link';
+import User from '#models/user';
-import User from '#user/models/user';
 import { belongsTo, column, hasMany } from '@adonisjs/lucid/orm';
 import type { BelongsTo, HasMany } from '@adonisjs/lucid/types/relations';
+import { Visibility } from '#enums/visibility';
 
 export default class Collection extends AppBaseModel {
 	@column()

app/models/link.ts

@@ -1,6 +1,6 @@
-import Collection from '#collections/models/collection';
+import AppBaseModel from '#models/app_base_model';
-import AppBaseModel from '#core/models/app_base_model';
+import Collection from '#models/collection';
-import User from '#user/models/user';
+import User from '#models/user';
 import { belongsTo, column } from '@adonisjs/lucid/orm';
 import type { BelongsTo } from '@adonisjs/lucid/types/relations';
 

app/models/user.ts

@@ -1,9 +1,9 @@
-import Collection from '#collections/models/collection';
+import Collection from '#models/collection';
-import AppBaseModel from '#core/models/app_base_model';
+import Link from '#models/link';
-import Link from '#links/models/link';
 import type { GoogleToken } from '@adonisjs/ally/types';
 import { column, computed, hasMany } from '@adonisjs/lucid/orm';
 import type { HasMany } from '@adonisjs/lucid/types/relations';
+import AppBaseModel from './app_base_model.js';
 import { DateTime } from 'luxon';
 
 export default class User extends AppBaseModel {

app/search/routes/routes.ts

@@ -1 +0,0 @@
-import './search_routes.js';

app/shared_collections/controllers/shared_collections_controller.ts

@@ -1,61 +0,0 @@
-import { Visibility } from '#collections/enums/visibility';
-import Collection from '#collections/models/collection';
-import Link from '#links/models/link';
-import User from '#user/models/user';
-import type { HttpContext } from '@adonisjs/core/http';
-import { getSharedCollectionValidator } from '../validators/shared_collection.js';
-
-class LinkWithoutFavoriteDto {
-	constructor(private link: Link) {}
-
-	toJson = () => ({
-		id: this.link.id,
-		name: this.link.name,
-		description: this.link.description,
-		url: this.link.url,
-		collectionId: this.link.collectionId,
-		createdAt: this.link.createdAt.toString(),
-		updatedAt: this.link.updatedAt.toString(),
-	});
-}
-
-class UserWithoutEmailDto {
-	constructor(private user: User) {}
-
-	toJson = () => ({
-		id: this.user.id,
-		fullname: this.user.name,
-		avatarUrl: this.user.avatarUrl,
-		isAdmin: this.user.isAdmin,
-		createdAt: this.user.createdAt.toString(),
-		updatedAt: this.user.updatedAt.toString(),
-	});
-}
-
-export default class SharedCollectionsController {
-	async index({ request, inertia }: HttpContext) {
-		const { params } = await request.validateUsing(
-			getSharedCollectionValidator
-		);
-
-		const collection = await this.getSharedCollectionById(params.id);
-		return inertia.render('shared', { collection });
-	}
-
-	private async getSharedCollectionById(id: Collection['id']) {
-		const collection = await Collection.query()
-			.where('id', id)
-			.andWhere('visibility', Visibility.PUBLIC)
-			.preload('links')
-			.preload('author')
-			.firstOrFail();
-
-		return {
-			...collection.serialize(),
-			links: collection.links.map((link) =>
-				new LinkWithoutFavoriteDto(link).toJson()
-			),
-			author: new UserWithoutEmailDto(collection.author).toJson(),
-		};
-	}
-}

app/shared_collections/routes/routes.ts

@@ -1 +0,0 @@
-import './shared_collections_routes.js';

app/types/query_params.ts

@@ -0,0 +1 @@
+export type QueryParams = { qs?: Record<string, any> };

app/types/tuyau.ts

@@ -0,0 +1,4 @@
+import { api } from '#adonisjs/api';
+
+export type RouteName = (typeof api)['routes'][number]['name'];
+export type RouteParams = (typeof api)['routes'][number]['params'];

app/user/constants/theme.ts

@@ -1,3 +0,0 @@
-export const KEY_USER_THEME = 'user_theme';
-export const THEMES = ['dark', 'light'] as const;
-export const DEFAULT_USER_THEME = THEMES.at(0);

app/user/controllers/theme_controller.ts

@@ -1,11 +0,0 @@
-import { KEY_USER_THEME } from '#user/constants/theme';
-import { updateThemeValidator } from '#user/validators/update_theme_validator';
-import type { HttpContext } from '@adonisjs/core/http';
-
-export default class ThemeController {
-	async index({ request, session, response }: HttpContext) {
-		const { theme } = await request.validateUsing(updateThemeValidator);
-		session.put(KEY_USER_THEME, theme);
-		return response.ok({ message: 'ok' });
-	}
-}

app/user/routes/routes.ts

@@ -1 +0,0 @@
-import './user_theme_route.js';

app/user/routes/user_theme_route.ts

@@ -1,5 +0,0 @@
-import router from '@adonisjs/core/services/router';
-
-const ThemeController = () => import('#user/controllers/theme_controller');
-
-router.post('/user/theme', [ThemeController, 'index']).as('user.theme');

app/user/validators/update_theme_validator.ts

@@ -1,8 +0,0 @@
-import { THEMES } from '#user/constants/theme';
-import vine from '@vinejs/vine';
-
-export const updateThemeValidator = vine.compile(
-	vine.object({
-		theme: vine.enum(THEMES),
-	})
-);

app/validators/collection.ts

@@ -1,6 +1,10 @@
-import { Visibility } from '#collections/enums/visibility';
+import { Visibility } from '#enums/visibility';
 import vine, { SimpleMessagesProvider } from '@vinejs/vine';
 
+const params = vine.object({
+	id: vine.number(),
+});
+
 export const createCollectionValidator = vine.compile(
 	vine.object({
 		name: vine.string().trim().minLength(1).maxLength(254),
@@ -10,6 +14,23 @@ export const createCollectionValidator = vine.compile(
 	})
 );
 
+export const updateCollectionValidator = vine.compile(
+	vine.object({
+		name: vine.string().trim().minLength(1).maxLength(254),
+		description: vine.string().trim().maxLength(254).nullable(),
+		visibility: vine.enum(Visibility),
+		nextId: vine.number().optional(),
+
+		params,
+	})
+);
+
+export const deleteCollectionValidator = vine.compile(
+	vine.object({
+		params,
+	})
+);
+
 createCollectionValidator.messagesProvider = new SimpleMessagesProvider({
 	name: 'Collection name is required',
 	'visibility.required': 'Collection visibiliy is required',

app/validators/link.ts

@@ -0,0 +1,43 @@
+import vine from '@vinejs/vine';
+
+const params = vine.object({
+	id: vine.number(),
+});
+
+export const createLinkValidator = vine.compile(
+	vine.object({
+		name: vine.string().trim().minLength(1).maxLength(254),
+		description: vine.string().trim().maxLength(300).optional(),
+		url: vine.string().trim(),
+		favorite: vine.boolean(),
+		collectionId: vine.number(),
+	})
+);
+
+export const updateLinkValidator = vine.compile(
+	vine.object({
+		name: vine.string().trim().minLength(1).maxLength(254),
+		description: vine.string().trim().maxLength(300).optional(),
+		url: vine.string().trim(),
+		favorite: vine.boolean(),
+		collectionId: vine.number(),
+
+		params,
+	})
+);
+
+export const deleteLinkValidator = vine.compile(
+	vine.object({
+		params,
+	})
+);
+
+export const updateLinkFavoriteStatusValidator = vine.compile(
+	vine.object({
+		favorite: vine.boolean(),
+
+		params: vine.object({
+			id: vine.number(),
+		}),
+	})
+);

app/validators/search_term.ts

@@ -0,0 +1,7 @@
+import vine from '@vinejs/vine';
+
+export const searchTermValidator = vine.compile(
+	vine.object({
+		searchTerm: vine.string().trim().minLength(1).maxLength(255),
+	})
+);

app/validators/shared_collection.ts

@@ -1,6 +1,9 @@
-import { params } from '#core/validators/params_object';
 import vine from '@vinejs/vine';
 
+const params = vine.object({
+	id: vine.number(),
+});
+
 export const getSharedCollectionValidator = vine.compile(
 	vine.object({
 		params,

app/validators/user.ts

@@ -0,0 +1,7 @@
+import vine from '@vinejs/vine';
+
+export const updateUserThemeValidator = vine.compile(
+	vine.object({
+		preferDarkTheme: vine.boolean(),
+	})
+);

config/auth.ts

@@ -1,6 +1,6 @@
 import { defineConfig } from '@adonisjs/auth';
+import { InferAuthEvents, Authenticators } from '@adonisjs/auth/types';
 import { sessionGuard, sessionUserProvider } from '@adonisjs/auth/session';
-import { Authenticators, InferAuthEvents } from '@adonisjs/auth/types';
 
 const authConfig = defineConfig({
 	default: 'web',
@@ -8,7 +8,7 @@ const authConfig = defineConfig({
 		web: sessionGuard({
 			useRememberMeTokens: false,
 			provider: sessionUserProvider({
-				model: () => import('#user/models/user'),
+				model: () => import('#models/user'),
 			}),
 		}),
 	},

config/inertia.ts

@@ -1,6 +1,7 @@
-import { isSSREnableForPage } from '#config/ssr';
+import {
-import { DEFAULT_USER_THEME, KEY_USER_THEME } from '#user/constants/theme';
+	DARK_THEME_DEFAULT_VALUE,
-import logger from '@adonisjs/core/services/logger';
+	PREFER_DARK_THEME,
+} from '#constants/session';
 import { defineConfig } from '@adonisjs/inertia';
 
 export default defineConfig({
@@ -14,9 +15,8 @@ export default defineConfig({
 	 */
 	sharedData: {
 		errors: (ctx) => ctx.session?.flashMessages.get('errors'),
-		user: (ctx) => ({
+		preferDarkTheme: (ctx) =>
-			theme: ctx.session?.get(KEY_USER_THEME, DEFAULT_USER_THEME),
+			ctx.session?.get(PREFER_DARK_THEME, DARK_THEME_DEFAULT_VALUE),
-		}),
 		auth: async (ctx) => {
 			await ctx.auth?.check();
 			return {
@@ -32,10 +32,5 @@ export default defineConfig({
 	ssr: {
 		enabled: true,
 		entrypoint: 'inertia/app/ssr.tsx',
-		pages: (_, page) => {
-			const ssrEnabled = isSSREnableForPage(page);
-			logger.debug(`Page "${page}" SSR enabled: ${ssrEnabled}`);
-			return ssrEnabled;
-		},
 	},
 });

config/project.ts

@@ -1,12 +0,0 @@
-const PROJECT_NAME = 'MyLinks';
-const PROJECT_DESCRIPTION =
-	'Another bookmark manager that lets you manage and share your favorite links in an intuitive interface';
-const PROJECT_URL = 'https://www.mylinks.app';
-const APP_COLOR = '#f0eef6';
-
-export default {
-	name: PROJECT_NAME,
-	description: PROJECT_DESCRIPTION,
-	url: PROJECT_URL,
-	color: APP_COLOR,
-};

config/ssr.ts

@@ -1,2 +0,0 @@
-export const CSR_ROUTES = ['dashboard'];
-export const isSSREnableForPage = (page: string) => !CSR_ROUTES.includes(page);

config/tuyau.ts

@@ -0,0 +1,17 @@
+import { defineConfig } from '@tuyau/core'
+
+const tuyauConfig = defineConfig({
+  codegen: {
+    /**
+     * Filters the definitions and named routes to be generated
+     */
+    // definitions: {
+    //  only: [],
+    // }
+    // routes: {
+    //  only: [],
+    // }
+  }
+})
+
+export default tuyauConfig

database/migrations/1714253983443_create_collections_table.ts

@@ -1,5 +1,5 @@
-import { Visibility } from '#collections/enums/visibility';
 import { defaultTableFields } from '#database/default_table_fields';
+import { Visibility } from '#enums/visibility';
 import { BaseSchema } from '@adonisjs/lucid/schema';
 
 export default class CreateCollectionTable extends BaseSchema {

database/seeders/collection_seeder.ts

@@ -1,6 +1,6 @@
-import { Visibility } from '#collections/enums/visibility';
+import { Visibility } from '#enums/visibility';
-import Collection from '#collections/models/collection';
+import Collection from '#models/collection';
-import User from '#user/models/user';
+import User from '#models/user';
 import { BaseSeeder } from '@adonisjs/lucid/seeders';
 import { faker } from '@faker-js/faker';
 

database/seeders/link_seeder.ts

@@ -1,7 +1,7 @@
-import Collection from '#collections/models/collection';
 import { getUserIds } from '#database/seeders/collection_seeder';
-import Link from '#links/models/link';
+import Collection from '#models/collection';
-import User from '#user/models/user';
+import Link from '#models/link';
+import User from '#models/user';
 import { BaseSeeder } from '@adonisjs/lucid/seeders';
 import { faker } from '@faker-js/faker';
 

database/seeders/user_seeder.ts

@@ -1,4 +1,4 @@
-import User from '#user/models/user';
+import User from '#models/user';
 import { GoogleToken } from '@adonisjs/ally/types';
 import { BaseSeeder } from '@adonisjs/lucid/seeders';
 import { faker } from '@faker-js/faker';

inertia/app/app.tsx

@@ -1,15 +1,16 @@
 import { resolvePageComponent } from '@adonisjs/inertia/helpers';
 import { createInertiaApp } from '@inertiajs/react';
-import { isSSREnableForPage } from 'config-ssr';
 import 'dayjs/locale/en';
 import 'dayjs/locale/fr';
-import { createRoot, hydrateRoot } from 'react-dom/client';
+import { hydrateRoot } from 'react-dom/client';
+import 'react-toggle/style.css';
+import { primaryColor } from '~/styles/common_colors';
 import '../i18n/index';
 
 const appName = import.meta.env.VITE_APP_NAME || 'MyLinks';
 
 createInertiaApp({
-	progress: { color: '#5474B4' },
+	progress: { color: primaryColor },
 
 	title: (title) => `${appName}${title && ` - ${title}`}`,
 
@@ -21,13 +22,6 @@ createInertiaApp({
 	},
 
 	setup({ el, App, props }) {
-		const componentName = props.initialPage.component;
+		hydrateRoot(el, <App {...props} />);
-		const isSSREnabled = isSSREnableForPage(componentName);
-		console.debug(`Page "${componentName}" SSR enabled: ${isSSREnabled}`);
-		if (isSSREnabled) {
-			hydrateRoot(el, <App {...props} />);
-		} else {
-			createRoot(el).render(<App {...props} />);
-		}
 	},
 });

inertia/components/admin/users/th.tsx

@@ -1,28 +0,0 @@
-import { Center, Group, rem, Table, Text, UnstyledButton } from '@mantine/core';
-import { PropsWithChildren } from 'react';
-import { TbChevronDown, TbChevronUp, TbSelector } from 'react-icons/tb';
-import classes from './users_table.module.css';
-
-interface ThProps extends PropsWithChildren {
-	reversed: boolean;
-	sorted: boolean;
-	onSort(): void;
-}
-
-export function Th({ children, reversed, sorted, onSort }: ThProps) {
-	const Icon = sorted ? (reversed ? TbChevronUp : TbChevronDown) : TbSelector;
-	return (
-		<Table.Th className={classes.th}>
-			<UnstyledButton onClick={onSort} className={classes.control}>
-				<Group justify="space-between">
-					<Text fw={500} fz="sm">
-						{children}
-					</Text>
-					<Center className={classes.icon}>
-						<Icon style={{ width: rem(16), height: rem(16) }} />
-					</Center>
-				</Group>
-			</UnstyledButton>
-		</Table.Th>
-	);
-}

inertia/components/admin/users/users_table.module.css

@@ -1,21 +0,0 @@
-.th {
-	padding: 0;
-}
-
-.control {
-	width: 100%;
-	padding: var(--mantine-spacing-xs) var(--mantine-spacing-md);
-
-	@mixin hover {
-		background-color: light-dark(
-			var(--mantine-color-gray-0),
-			var(--mantine-color-dark-6)
-		);
-	}
-}
-
-.icon {
-	width: rem(21px);
-	height: rem(21px);
-	border-radius: rem(21px);
-}

inertia/components/admin/users/users_table.tsx

@@ -1,174 +0,0 @@
-import {
-	ScrollArea,
-	Table,
-	Text,
-	TextInput,
-	Tooltip,
-	rem,
-} from '@mantine/core';
-import dayjs from 'dayjs';
-import relativeTime from 'dayjs/plugin/relativeTime';
-import { ChangeEvent, useState } from 'react';
-import { useTranslation } from 'react-i18next';
-import { TbSearch } from 'react-icons/tb';
-import { Th } from '~/components/admin/users/th';
-import { sortData } from '~/components/admin/users/utils';
-import { UserBadgeRole } from '~/components/common/user_badge_role';
-import { DATE_FORMAT } from '~/constants';
-import { User } from '~/types/app';
-
-dayjs.extend(relativeTime);
-
-export type UserWithCounts = User & {
-	linksCount: number;
-	collectionsCount: number;
-};
-export type UsersWithCounts = UserWithCounts[];
-
-export type Columns = keyof UserWithCounts;
-
-const DEFAULT_SORT_BY: Columns = 'lastSeenAt';
-const DEFAULT_SORT_DIRECTION = true;
-
-export interface UsersTableProps {
-	users: UsersWithCounts;
-	totalCollections: number;
-	totalLinks: number;
-}
-
-export function UsersTable({
-	users,
-	totalCollections,
-	totalLinks,
-}: UsersTableProps) {
-	const { t } = useTranslation();
-
-	const [search, setSearch] = useState<string>('');
-	const [sortBy, setSortBy] = useState<Columns | null>(DEFAULT_SORT_BY);
-	const [reverseSortDirection, setReverseSortDirection] = useState(
-		DEFAULT_SORT_DIRECTION
-	);
-	const [sortedData, setSortedData] = useState(() =>
-		sortData(users, {
-			sortBy: sortBy,
-			reversed: reverseSortDirection,
-			search: '',
-		})
-	);
-
-	const setSorting = (field: keyof UserWithCounts) => {
-		const reversed = field === sortBy ? !reverseSortDirection : false;
-		setReverseSortDirection(reversed);
-		setSortBy(field);
-		setSortedData(sortData(users, { sortBy: field, reversed, search }));
-	};
-
-	const handleSearchChange = (event: ChangeEvent<HTMLInputElement>) => {
-		const { value } = event.currentTarget;
-		setSearch(value);
-		setSortedData(
-			sortData(users, {
-				sortBy: sortBy,
-				reversed: reverseSortDirection,
-				search: value,
-			})
-		);
-	};
-
-	const renderDateCell = (date: string) => (
-		<Tooltip label={dayjs(date).format(DATE_FORMAT).toString()}>
-			<Text>{dayjs(date).fromNow()}</Text>
-		</Tooltip>
-	);
-
-	const rows = sortedData.map((user) => (
-		<Table.Tr key={user.id}>
-			<Table.Td>{user.fullname}</Table.Td>
-			<Table.Td>
-				<UserBadgeRole user={user} />
-			</Table.Td>
-			<Table.Td>{user.collectionsCount}</Table.Td>
-			<Table.Td>{user.linksCount}</Table.Td>
-			<Table.Td>{renderDateCell(user.createdAt)}</Table.Td>
-			<Table.Td>{renderDateCell(user.lastSeenAt)}</Table.Td>
-		</Table.Tr>
-	));
-
-	return (
-		<ScrollArea>
-			<TextInput
-				placeholder={`Search by any field (${users.length} users)`}
-				mb="md"
-				leftSection={<TbSearch style={{ width: rem(16), height: rem(16) }} />}
-				value={search}
-				onChange={handleSearchChange}
-			/>
-			<Table
-				horizontalSpacing="md"
-				verticalSpacing="xs"
-				miw={700}
-				layout="fixed"
-			>
-				<Table.Tbody>
-					<Table.Tr>
-						<Th
-							sorted={sortBy === 'fullname'}
-							reversed={reverseSortDirection}
-							onSort={() => setSorting('fullname')}
-						>
-							{t('common:name')}
-						</Th>
-						<Th
-							sorted={sortBy === 'isAdmin'}
-							reversed={reverseSortDirection}
-							onSort={() => setSorting('isAdmin')}
-						>
-							{t('admin:role')}
-						</Th>
-						<Th
-							sorted={sortBy === 'collectionsCount'}
-							reversed={reverseSortDirection}
-							onSort={() => setSorting('collectionsCount')}
-						>
-							{t('common:collection.collections')} ({totalCollections})
-						</Th>
-						<Th
-							sorted={sortBy === 'linksCount'}
-							reversed={reverseSortDirection}
-							onSort={() => setSorting('linksCount')}
-						>
-							{t('common:link.links')} ({totalLinks})
-						</Th>
-						<Th
-							sorted={sortBy === 'createdAt'}
-							reversed={reverseSortDirection}
-							onSort={() => setSorting('createdAt')}
-						>
-							{t('admin:created_at')}
-						</Th>
-						<Th
-							sorted={sortBy === 'lastSeenAt'}
-							reversed={reverseSortDirection}
-							onSort={() => setSorting('lastSeenAt')}
-						>
-							{t('admin:last_seen_at')}
-						</Th>
-					</Table.Tr>
-				</Table.Tbody>
-				<Table.Tbody>
-					{rows.length > 0 ? (
-						rows
-					) : (
-						<Table.Tr>
-							<Table.Td colSpan={4}>
-								<Text fw={500} ta="center">
-									Nothing found
-								</Text>
-							</Table.Td>
-						</Table.Tr>
-					)}
-				</Table.Tbody>
-			</Table>
-		</ScrollArea>
-	);
-}

inertia/components/admin/users/utils.ts

@@ -1,39 +0,0 @@
-import {
-	UsersWithCounts,
-	UserWithCounts,
-} from '~/components/admin/users/users_table';
-
-export function filterData(data: UsersWithCounts, search: string) {
-	const query = search.toLowerCase().trim();
-	return data.filter((item) =>
-		['email', 'name', 'nickName', 'fullname'].some((key) => {
-			const value = item[key as keyof UserWithCounts];
-			return typeof value === 'string' && value.toLowerCase().includes(query);
-		})
-	);
-}
-
-export function sortData(
-	data: UsersWithCounts,
-	payload: {
-		sortBy: keyof UserWithCounts | null;
-		reversed: boolean;
-		search: string;
-	}
-) {
-	const { sortBy } = payload;
-
-	if (!sortBy) {
-		return filterData(data, payload.search);
-	}
-
-	return filterData(
-		[...data].sort((a, b) => {
-			if (payload.reversed) {
-				return b[sortBy] > a[sortBy] ? 1 : -1;
-			}
-			return a[sortBy] > b[sortBy] ? 1 : -1;
-		}),
-		payload.search
-	);
-}

inertia/components/common/dropdown/dropdown.tsx

@@ -0,0 +1,64 @@
+import styled from '@emotion/styled';
+import { HtmlHTMLAttributes, ReactNode, useRef } from 'react';
+import DropdownContainer from '~/components/common/dropdown/dropdown_container';
+import DropdownLabel from '~/components/common/dropdown/dropdown_label';
+import useClickOutside from '~/hooks/use_click_outside';
+import useToggle from '~/hooks/use_modal';
+import useShortcut from '~/hooks/use_shortcut';
+
+const DropdownStyle = styled.div<{ opened: boolean; svgSize?: number }>(
+	({ opened, theme, svgSize = 24 }) => ({
+		cursor: 'pointer',
+		userSelect: 'none',
+		position: 'relative',
+		minWidth: 'fit-content',
+		width: 'fit-content',
+		maxWidth: '250px',
+		backgroundColor: opened ? theme.colors.secondary : theme.colors.background,
+		padding: '4px',
+		borderRadius: theme.border.radius,
+
+		'&:hover': {
+			backgroundColor: theme.colors.secondary,
+		},
+
+		'& svg': {
+			height: `${svgSize}px`,
+			width: `${svgSize}px`,
+		},
+	})
+);
+
+export default function Dropdown({
+	children,
+	label,
+	className,
+	svgSize,
+	onClick,
+}: HtmlHTMLAttributes<HTMLDivElement> & {
+	label: ReactNode | string;
+	className?: string;
+	svgSize?: number;
+}) {
+	const dropdownRef = useRef<HTMLDivElement>(null);
+	const { isShowing, toggle, close } = useToggle();
+
+	useClickOutside(dropdownRef, close);
+	useShortcut('ESCAPE_KEY', close, { disableGlobalCheck: true });
+
+	return (
+		<DropdownStyle
+			opened={isShowing}
+			onClick={(event) => {
+				onClick?.(event);
+				toggle();
+			}}
+			ref={dropdownRef}
+			className={className}
+			svgSize={svgSize}
+		>
+			<DropdownLabel>{label}</DropdownLabel>
+			<DropdownContainer show={isShowing}>{children}</DropdownContainer>
+		</DropdownStyle>
+	);
+}

inertia/components/common/dropdown/dropdown_container.tsx

@@ -0,0 +1,21 @@
+import styled from '@emotion/styled';
+import TransitionLayout from '~/components/layouts/_transition_layout';
+
+const DropdownContainer = styled(TransitionLayout)<{ show: boolean }>(
+	({ show, theme }) => ({
+		zIndex: 99,
+		position: 'absolute',
+		top: 'calc(100% + 0.5em)',
+		right: 0,
+		minWidth: '175px',
+		backgroundColor: show ? theme.colors.secondary : theme.colors.background,
+		border: `2px solid ${theme.colors.secondary}`,
+		borderRadius: theme.border.radius,
+		boxShadow: theme.colors.boxShadow,
+		display: show ? 'flex' : 'none',
+		flexDirection: 'column',
+		overflow: 'hidden',
+	})
+);
+
+export default DropdownContainer;

inertia/components/common/dropdown/dropdown_item.tsx

@@ -0,0 +1,31 @@
+import styled from '@emotion/styled';
+import { Link } from '@inertiajs/react';
+
+const DropdownItemBase = styled('div', {
+	shouldForwardProp: (propName) => propName !== 'danger',
+})<{ danger?: boolean }>(({ theme, danger }) => ({
+	fontSize: '14px',
+	whiteSpace: 'nowrap',
+	color: danger ? theme.colors.lightRed : theme.colors.primary,
+	padding: '8px 12px',
+	borderRadius: theme.border.radius,
+
+	'&:hover': {
+		backgroundColor: theme.colors.background,
+	},
+}));
+
+const DropdownItemButton = styled(DropdownItemBase)({
+	display: 'flex',
+	gap: '0.75em',
+	alignItems: 'center',
+});
+
+const DropdownItemLink = styled(DropdownItemBase.withComponent(Link))({
+	width: '100%',
+	display: 'flex',
+	gap: '0.75em',
+	alignItems: 'center',
+});
+
+export { DropdownItemButton, DropdownItemLink };

inertia/components/common/dropdown/dropdown_label.tsx

@@ -0,0 +1,11 @@
+import styled from '@emotion/styled';
+
+const DropdownLabel = styled.div(({ theme }) => ({
+	height: 'auto',
+	width: 'auto',
+	color: theme.colors.font,
+	display: 'flex',
+	gap: '0.35em',
+}));
+
+export default DropdownLabel;

inertia/components/common/external_link_styled.tsx

@@ -1,26 +0,0 @@
-import { Anchor } from '@mantine/core';
-import { AnchorHTMLAttributes, CSSProperties, ReactNode } from 'react';
-
-export function ExternalLinkStyled({
-	children,
-	title,
-	...props
-}: AnchorHTMLAttributes<HTMLAnchorElement> & {
-	children: ReactNode;
-	style?: CSSProperties;
-	title?: string;
-	className?: string;
-}) {
-	return (
-		<Anchor<'a'>
-			component="a"
-			underline="never"
-			target="_blank"
-			rel="noreferrer"
-			title={title}
-			{...props}
-		>
-			{children}
-		</Anchor>
-	);
-}

inertia/components/common/form/_button.tsx

@@ -0,0 +1,31 @@
+import styled from '@emotion/styled';
+
+const Button = styled.button<{ danger?: boolean }>(({ theme, danger }) => {
+	const btnColor = !danger ? theme.colors.primary : theme.colors.lightRed;
+	const btnDarkColor = !danger ? theme.colors.darkBlue : theme.colors.lightRed;
+	return {
+		cursor: 'pointer',
+		width: '100%',
+		textTransform: 'uppercase',
+		fontSize: '14px',
+		color: theme.colors.white,
+		background: btnColor,
+		padding: '0.75em',
+		border: `1px solid ${btnColor}`,
+		borderRadius: theme.border.radius,
+		transition: theme.transition.delay,
+
+		'&:disabled': {
+			cursor: 'not-allowed',
+			opacity: '0.5',
+		},
+
+		'&:not(:disabled):hover': {
+			boxShadow: `${btnDarkColor} 0 0 3px 1px`,
+			background: btnDarkColor,
+			color: theme.colors.white,
+		},
+	};
+});
+
+export default Button;

inertia/components/common/form/_form.tsx

@@ -0,0 +1,10 @@
+import styled from '@emotion/styled';
+
+const Form = styled.form({
+	width: '100%',
+	display: 'flex',
+	gap: '1em',
+	flexDirection: 'column',
+});
+
+export default Form;

inertia/components/common/form/_form_field.tsx

@@ -0,0 +1,25 @@
+import styled from '@emotion/styled';
+
+const FormField = styled('div', {
+	shouldForwardProp: (propName) => propName !== 'required',
+})<{ required?: boolean }>(({ required, theme }) => ({
+	display: 'flex',
+	gap: '0.25em',
+	flexDirection: 'column',
+
+	'& label': {
+		position: 'relative',
+		userSelect: 'none',
+		width: 'fit-content',
+	},
+
+	'& label::after': {
+		position: 'absolute',
+		top: 0,
+		right: '-0.75em',
+		color: theme.colors.lightRed,
+		content: (required ? '"*"' : '""') as any,
+	},
+}));
+
+export default FormField;

inertia/components/common/form/_form_field_error.tsx

@@ -0,0 +1,9 @@
+import styled from '@emotion/styled';
+
+// TODO: create a global style variable (fontSize)
+const FormFieldError = styled.p(({ theme }) => ({
+	fontSize: '12px',
+	color: theme.colors.lightRed,
+}));
+
+export default FormFieldError;

inertia/components/common/form/_input.tsx

@@ -0,0 +1,27 @@
+import styled from '@emotion/styled';
+
+const Input = styled.input(({ theme }) => ({
+	width: '100%',
+	color: theme.colors.font,
+	backgroundColor: theme.colors.secondary,
+	padding: '0.75em',
+	border: `1px solid ${theme.colors.lightGrey}`,
+	borderBottom: `2px solid ${theme.colors.lightGrey}`,
+	borderRadius: theme.border.radius,
+	transition: theme.transition.delay,
+
+	'&:focus': {
+		borderBottom: `2px solid ${theme.colors.primary}`,
+	},
+
+	'&:disabled': {
+		opacity: 0.85,
+	},
+
+	'&::placeholder': {
+		fontStyle: 'italic',
+		color: theme.colors.grey,
+	},
+}));
+
+export default Input;

inertia/components/common/form/checkbox.tsx

@@ -0,0 +1,55 @@
+import { ChangeEvent, Fragment, InputHTMLAttributes, useState } from 'react';
+import Toggle from 'react-toggle';
+import FormField from '~/components/common/form/_form_field';
+import FormFieldError from '~/components/common/form/_form_field_error';
+
+interface InputProps
+	extends Omit<InputHTMLAttributes<HTMLInputElement>, 'onChange'> {
+	label: string;
+	name: string;
+	checked: boolean;
+	errors?: string[];
+	onChange?: (name: string, checked: boolean) => void;
+}
+
+export default function Checkbox({
+	name,
+	label,
+	checked = false,
+	errors = [],
+	onChange,
+	required = false,
+	...props
+}: InputProps): JSX.Element {
+	const [checkboxChecked, setCheckboxChecked] = useState<boolean>(checked);
+
+	if (typeof window === 'undefined') return <Fragment />;
+
+	function _onChange({ target }: ChangeEvent<HTMLInputElement>) {
+		setCheckboxChecked(target.checked);
+		if (onChange) {
+			onChange(target.name, target.checked);
+		}
+	}
+
+	return (
+		<FormField
+			css={{ alignItems: 'center', gap: '1em', flexDirection: 'row' }}
+			required={required}
+		>
+			<label htmlFor={name} title={label}>
+				{label}
+			</label>
+			<Toggle
+				{...props}
+				onChange={_onChange}
+				checked={checkboxChecked}
+				placeholder={props.placeholder ?? 'Type something...'}
+				name={name}
+				id={name}
+			/>
+			{errors.length > 0 &&
+				errors.map((error) => <FormFieldError>{error}</FormFieldError>)}
+		</FormField>
+	);
+}

inertia/components/common/form/selector.tsx

@@ -0,0 +1,79 @@
+import { useTheme } from '@emotion/react';
+import { InputHTMLAttributes, ReactNode, useEffect, useState } from 'react';
+import Select, {
+	FormatOptionLabelMeta,
+	GroupBase,
+	OptionsOrGroups,
+} from 'react-select';
+import FormField from '~/components/common/form/_form_field';
+
+type Option = { label: string | number; value: string | number };
+
+interface SelectorProps
+	extends Omit<InputHTMLAttributes<HTMLInputElement>, 'onChange'> {
+	label: string;
+	name: string;
+	errors?: string[];
+	options: OptionsOrGroups<Option, GroupBase<Option>>;
+	value: number | string;
+	onChangeCallback?: (value: number | string) => void;
+	formatOptionLabel?: (
+		data: Option,
+		formatOptionLabelMeta: FormatOptionLabelMeta<Option>
+	) => ReactNode;
+}
+
+export default function Selector({
+	name,
+	label,
+	value,
+	errors = [],
+	options,
+	onChangeCallback,
+	formatOptionLabel,
+	required = false,
+	...props
+}: SelectorProps): JSX.Element {
+	const theme = useTheme();
+	const [selectorValue, setSelectorValue] = useState<Option>();
+
+	useEffect(() => {
+		if (options.length === 0) return;
+
+		const option = options.find((o: any) => o.value === value);
+		if (option) {
+			setSelectorValue(option as Option);
+		}
+	}, [options, value]);
+
+	const handleChange = (selectedOption: Option) => {
+		setSelectorValue(selectedOption);
+		if (onChangeCallback) {
+			onChangeCallback(selectedOption.value);
+		}
+	};
+
+	return (
+		<FormField required={required}>
+			{label && (
+				<label htmlFor={name} title={`${name} field`}>
+					{label}
+				</label>
+			)}
+			<Select
+				value={selectorValue}
+				onChange={(newValue) => handleChange(newValue as Option)}
+				options={options}
+				isDisabled={props.disabled}
+				menuPlacement="auto"
+				formatOptionLabel={
+					formatOptionLabel
+						? (val, formatOptionLabelMeta) =>
+								formatOptionLabel(val, formatOptionLabelMeta)
+						: undefined
+				}
+				css={{ color: theme.colors.black }}
+			/>
+		</FormField>
+	);
+}

inertia/components/common/form/textbox.tsx

@@ -0,0 +1,49 @@
+import { ChangeEvent, InputHTMLAttributes, useState } from 'react';
+import FormField from '~/components/common/form/_form_field';
+import FormFieldError from '~/components/common/form/_form_field_error';
+import Input from '~/components/common/form/_input';
+
+interface InputProps
+	extends Omit<InputHTMLAttributes<HTMLInputElement>, 'onChange'> {
+	label: string;
+	name: string;
+	value?: string;
+	errors?: string[];
+	onChange?: (name: string, value: string) => void;
+}
+
+export default function TextBox({
+	name,
+	label,
+	value = '',
+	errors = [],
+	onChange,
+	required = false,
+	...props
+}: InputProps): JSX.Element {
+	const [inputValue, setInputValue] = useState<string>(value);
+
+	function _onChange({ target }: ChangeEvent<HTMLInputElement>) {
+		setInputValue(target.value);
+		if (onChange) {
+			onChange(target.name, target.value);
+		}
+	}
+
+	return (
+		<FormField required={required}>
+			<label htmlFor={name} title={label}>
+				{label}
+			</label>
+			<Input
+				{...props}
+				name={name}
+				onChange={_onChange}
+				value={inputValue}
+				placeholder={props.placeholder ?? 'Type something...'}
+			/>
+			{errors.length > 0 &&
+				errors.map((error) => <FormFieldError>{error}</FormFieldError>)}
+		</FormField>
+	);
+}

inertia/components/common/icon_button.tsx

@@ -0,0 +1,22 @@
+import styled from '@emotion/styled';
+
+const IconButton = styled.button(({ theme }) => ({
+	cursor: 'pointer',
+	height: '2rem',
+	width: '2rem',
+	fontSize: '1rem',
+	color: theme.colors.font,
+	backgroundColor: theme.colors.grey,
+	borderRadius: '50%',
+	border: 0,
+	display: 'flex',
+	alignItems: 'center',
+	justifyContent: 'center',
+
+	'&:disabled': {
+		cursor: 'not-allowed',
+		opacity: 0.15,
+	},
+}));
+
+export default IconButton;