monoid/simple-fs-server
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Compare commits

base: monoid:312964f22c2281ec6414847cc8d4c83b0945640f
Branches Tags
monoid:main
..
compare: monoid:d959076d284f6208dc46239cea065a3e4aa0d3cb
Branches Tags
monoid:main

No commits in common. "312964f22c2281ec6414847cc8d4c83b0945640f" and "d959076d284f6208dc46239cea065a3e4aa0d3cb" have entirely different histories.
312964f22c ... d959076d28

34 changed files with 1038 additions and 1185 deletions
Show Stats Expand all files Collapse all files

16
islands/ContentRenderer.tsx
View File

@ -9,7 +9,7 @@ const TypeToExt = {
"md": new Set([".md"]), "md": new Set([".md"]),
"text": new Set([".txt"]), "text": new Set([".txt"]),
"code": new Set([".json", ".js", ".ts", ".css", ".tsx", ".jsx"]), "code": new Set([".json", ".js", ".ts", ".css", ".tsx", ".jsx"]),
}; }
function extToType(ext: string) { function extToType(ext: string) {
for (const [type, exts] of Object.entries(TypeToExt)) { for (const [type, exts] of Object.entries(TypeToExt)) {
@ -20,12 +20,12 @@ function extToType(ext: string) {
return "unknown"; return "unknown";
} }
function FetchAndRender(props: { src: string; type: string }) { function FetchAndRender(props: {src: string, type: string}){
const src = props.src; const src = props.src;
const ext = extname(src); const ext = extname(src);
const [content, setContent] = useState(""); const [content, setContent] = useState("");
useEffect(() => { useEffect(() => {
fetch(src).then((res) => res.text()).then(setContent); fetch(src).then(res => res.text()).then(setContent);
}, [src]); }, [src]);
switch (props.type) { switch (props.type) {
case "text": case "text":
@ -33,11 +33,7 @@ function FetchAndRender(props: { src: string; type: string }) {
case "md": case "md":
return <MarkdownRenderer text={content} />; return <MarkdownRenderer text={content} />;
case "code": case "code":
return ( return <pre style={{ whiteSpace: "pre-wrap" }}><code lang={ext.slice(1)}>{content}</code></pre>;
<pre
style={{ whiteSpace: "pre-wrap" }}
><code lang={ext.slice(1)}>{content}</code></pre>
);
//case "csv": //case "csv":
// return <CsvRenderer content={content} />; // return <CsvRenderer content={content} />;
default: default:
@ -45,14 +41,14 @@ function FetchAndRender(props: { src: string; type: string }) {
} }
} }
export function RenderView(props: { src: string }) { export function RenderView(props: {src: string}) {
const src = props.src; const src = props.src;
const type = extToType(extname(src)); const type = extToType(extname(src));
switch (type) { switch (type) {
case "text": case "text":
case "md": case "md":
case "code": case "code":
return <FetchAndRender src={src} type={type}></FetchAndRender>; return <FetchAndRender src={src} type={type}></FetchAndRender>
//case "csv": //case "csv":
// return <CsvRenderer content={content} />; // return <CsvRenderer content={content} />;
case "image": case "image":

68
islands/DirList.tsx
View File

@ -1,27 +1,25 @@
import { asset, Head } from "$fresh/runtime.ts"; import { Head, asset } from "$fresh/runtime.ts";
import { useState } from "preact/hooks"; import { useState } from "preact/hooks";
import { extname, join } from "path/posix.ts"; import { extname, join } from "path/posix.ts";
import { ComponentChild } from "preact"; import { ComponentChild } from "preact";
import UpList from "./UpList.tsx"; import UpList from "./UpList.tsx";
import { extToIcon } from "../src/media.ts"; import {extToIcon} from "../src/media.ts";
import { encodePath } from "../util/util.ts"; import { encodePath } from "../util/util.ts";
function ListItem(props: { function ListItem(props:{
href: string; href: string,
icon: string; icon: string,
children: ComponentChild; children: ComponentChild
}) { }) {
return ( return (
<li class="p-1 hover:bg-gray-400 transition-colors"> <li class="p-1 hover:bg-gray-400 transition-colors">
<a class="flex gap-2" href={props.href}> <a class="flex gap-2" href={props.href}>
<img src={asset(props.icon)} /> <img src={asset(props.icon)}/><p class="">{props.children}</p></a>
<p class="">{props.children}</p>
</a>
</li> </li>
); );
} }
export interface EntryInfo { export interface EntryInfo{
name: string; name: string;
isFile: boolean; isFile: boolean;
isDirectory: boolean; isDirectory: boolean;
@ -39,44 +37,33 @@ export function DirList(props: DirListProps) {
const data = props; const data = props;
const [files, setFiles] = useState(data.files); const [files, setFiles] = useState(data.files);
return ( return (<div>
<div>
<UpList path={data.path}></UpList> <UpList path={data.path}></UpList>
<ul class="border-2 rounded-md"> <ul class="border-2 rounded-md">
<li class="p-1 flex gap-2"> <li class="p-1 flex gap-2">
<button class="flex" onClick={sortDir}> <button class="flex" onClick={sortDir}>
<img src={asset("/icon/sort-down.svg")} /> Sort Directory <img src={asset("/icon/sort-down.svg")}/> Sort Directory
</button> </button>
<button class="flex" onClick={sortAlpha}> <button class="flex" onClick={sortAlpha}>
<img src={asset("/icon/sort-alpha-down.svg")} /> Sort Alphabet <img src={asset("/icon/sort-alpha-down.svg")} /> Sort Alphabet
</button> </button>
</li> </li>
<ListItem <ListItem key=".." href={`/dir/${encodePath(join(data.path,".."))}`}
key=".."
href={`/dir/${encodePath(join(data.path, ".."))}`}
icon="/icon/back.svg" icon="/icon/back.svg"
> >...</ListItem>
...
</ListItem>
{files.map((file) => ( {files.map((file) => (
<ListItem <ListItem key={file.name} href={`/dir/${encodePath(join(data.path,file.name))}`}
key={file.name} icon={file.isDirectory ? "/icon/folder.svg": extToIcon(extname(file.name))}
href={`/dir/${encodePath(join(data.path, file.name))}`} >{file.name}</ListItem>
icon={file.isDirectory
? "/icon/folder.svg"
: extToIcon(extname(file.name))}
>
{file.name}
</ListItem>
))} ))}
</ul> </ul>
</div> </div>)
);
function sortDir() { function sortDir() {
// sort by directory first then by index // sort by directory first then by index
const sorted_files = files.map((x, i) => ([x, i] as [EntryInfo, number])) const sorted_files = files.map((x,i)=>
([x,i] as [EntryInfo, number]))
.sort( .sort(
([a, ai], [b, bi]) => { ([a, ai],[b,bi]) => {
if (a.isDirectory && !b.isDirectory) { if (a.isDirectory && !b.isDirectory) {
return -1; return -1;
} else if (!a.isDirectory && b.isDirectory) { } else if (!a.isDirectory && b.isDirectory) {
@ -84,24 +71,23 @@ export function DirList(props: DirListProps) {
} else { } else {
return ai - bi; return ai - bi;
} }
}, });
); setFiles(sorted_files.map(([x,_])=>x));
setFiles(sorted_files.map(([x, _]) => x));
} }
function sortAlpha() { function sortAlpha() {
// sort by alphabet first then by index // sort by alphabet first then by index
const sorted_files = files.map((x, i) => ([x, i] as [EntryInfo, number])) const sorted_files = files.map((x,i)=>
([x,i] as [EntryInfo, number]))
.sort( .sort(
([a, ai], [b, bi]) => { ([a, ai],[b,bi]) => {
const ret = a.name.localeCompare(b.name); const ret = a.name.localeCompare(b.name);
if (ret === 0) { if (ret === 0) {
return ai - bi; return ai - bi;
} else { } else {
return ret; return ret;
} }
}, });
); setFiles(sorted_files.map(([x,_])=>x));
setFiles(sorted_files.map(([x, _]) => x));
} }
} }

33
islands/DocSearch.tsx
View File

@ -3,52 +3,43 @@ import { useEffect, useState } from "preact/hooks";
import { Index } from "../src/client_search.ts"; import { Index } from "../src/client_search.ts";
import { encodePath } from "../util/util.ts"; import { encodePath } from "../util/util.ts";
function SearchBar(props: { function SearchBar(props:{
search?: string; search?: string;
onSearch?: (search: string) => void; onSearch?: (search: string) => void;
}) { }){
const [search, setSearch] = useState(props.search ?? ""); const [search, setSearch] = useState(props.search ?? "");
return ( return (
<div class="flex items-center justify-center"> <div class="flex items-center justify-center">
<input <input type="text" class="w-1/2 px-4 py-2 border-2 rounded-lg" placeholder="Search..."
type="text"
class="w-1/2 px-4 py-2 border-2 rounded-lg"
placeholder="Search..."
//onChange={(event)=>{}} //onChange={(event)=>{}}
onKeyUp={(event) => { onKeyUp={(event)=>{
if (event.currentTarget.value === search) return; if (event.currentTarget.value === search) return;
setSearch(event.currentTarget.value); setSearch(event.currentTarget.value);
props.onSearch?.(event.currentTarget.value); props.onSearch?.(event.currentTarget.value);
}} }}>{search}</input>
>
{search}
</input>
</div> </div>
); )
} }
export default function DocSearch(props: { export default function DocSearch(props: {
docs: Doc[]; docs: Doc[]
}) { }){
const [docs, setDocs] = useState(props.docs); const [docs, setDocs] = useState(props.docs);
const index = Index.createIndex(props.docs); const index = Index.createIndex(props.docs);
return ( return (
<> <>
<SearchBar <SearchBar onSearch={(s)=>{
onSearch={(s) => {
setDocs(index.search(s)); setDocs(index.search(s));
}} }}></SearchBar>
>
</SearchBar>
<h1 class="text-2xl font-bold">Doc</h1> <h1 class="text-2xl font-bold">Doc</h1>
<ul class="mt-4"> <ul class="mt-4">
{docs.map((doc) => ( {docs.map((doc) => (
<li class="mt-2"> <li class="mt-2">
<a href={`/dir/${encodePath(doc.path)}`}>{doc.path}</a> <a href={`/dir/${encodePath(doc.path)}`}> {doc.path}</a>
</li> </li>
))} ))}
</ul> </ul>
</> </>
); )
} }

4
islands/FileViewer.tsx
View File

@ -11,8 +11,8 @@ export default function FileViewer(props: { path: string }) {
<UpList path={path} /> <UpList path={path} />
<a href={srcPath}>Direct link</a> <a href={srcPath}>Direct link</a>
<div class="p-2 border-2 rounded-lg"> <div class="p-2 border-2 rounded-lg">
<RenderView src={srcPath} /> <RenderView src={srcPath}/>
</div> </div>
</div> </div>
); )
} }

9
islands/MarkdownRenderer.tsx
View File

@ -5,14 +5,9 @@ export function MarkdownRenderer(props: { text: string | undefined }) {
if (text === undefined) { if (text === undefined) {
text = ""; text = "";
} }
const index = text.indexOf("\n---", 3); const index = text.indexOf('\n---', 3);
const c = text.slice(index + 4, text.length); const c = text.slice(index + 4, text.length);
return ( return <div class="markdown-body" dangerouslySetInnerHTML={{ __html: marked.parse(c) }} />;
<div
class="markdown-body"
dangerouslySetInnerHTML={{ __html: marked.parse(c) }}
/>
);
} }
export default MarkdownRenderer; export default MarkdownRenderer;

32
islands/UpList.tsx
View File

@ -1,44 +1,40 @@
import { asset, Head } from "$fresh/runtime.ts"; import { Head, asset } from "$fresh/runtime.ts";
import { join } from "path/posix.ts"; import { join } from "path/posix.ts";
import { ComponentChild } from "preact"; import { ComponentChild } from "preact";
import { encodePath } from "../util/util.ts"; import { encodePath } from "../util/util.ts";
function stairs(path: string) {
function stairs(path: string){
if (path === ".") return []; if (path === ".") return [];
const uplist = path.split("/"); const uplist = path.split("/");
let current = "."; let current = ".";
const stairs = []; const stairs = [];
for (const up of uplist) { for (const up of uplist){
current = join(current, up); current = join(current, up);
stairs.push([current, up]); stairs.push([current, up]);
} }
return stairs; return stairs;
} }
export default function UpList(props: { path: string }) { export default function UpList(props:{path: string}) {
const data = props; const data = props;
const uplist = stairs(data.path); const uplist = stairs(data.path);
return ( return (<div>
<div>
<h1 class={"text-2xl flex flex-wrap"}> <h1 class={"text-2xl flex flex-wrap"}>
<a href="/dir/" class="flex flex-wrap p-2 hover:bg-gray-400 rounded-sm"> <a href="/dir/" class="flex flex-wrap p-2 hover:bg-gray-400 rounded-sm">
<img src={asset("/icon/house.svg")} /> <img src={asset("/icon/house.svg")}/>
<span class="ml-1">Home</span> <span class="ml-1">Home</span></a>
</a> {
{uplist.map(([cur, up], i) => ( uplist.map(([cur, up], i) => (
<> <>
<span class="p-2">/</span> <span class="p-2">/</span>
<a <a class="flex flex-wrap p-2 hover:bg-gray-400 rounded-sm" href={`/dir/${encodePath(cur)}`}>
class="flex flex-wrap p-2 hover:bg-gray-400 rounded-sm"
href={`/dir/${encodePath(cur)}`}
>
<img src={asset("/icon/folder.svg")} /> <img src={asset("/icon/folder.svg")} />
<span class="ml-1">{up}</span> <span class="ml-1">{up}</span>
</a> </a>
</> </>
))} ))
</h1> }</h1>
</div> </div>)
);
} }

19
keyout.ts
View File

@ -4,27 +4,24 @@ import { prepareSecretKey } from "./util/secret.ts";
export const key_out_cmd = new Command(); export const key_out_cmd = new Command();
key_out_cmd.name("keyout") key_out_cmd.name("keyout")
.description("Output the secret key.") .description("Output the secret key.")
.option( .option("-f, --file <file:string>", "The file to output the key to. (default: stdout)")
"-f, --file <file:string>", .option("--dotenv", "Output the key in dotenv format.")
"The file to output the key to. (default: stdout)", .action(async ({file, dotenv}) => {
)
.option("--dotenv", "Output the key in dotenv format.")
.action(async ({ file, dotenv }) => {
const key = await prepareSecretKey(); const key = await prepareSecretKey();
const keyout = await crypto.subtle.exportKey("jwk", key); const keyout = await crypto.subtle.exportKey("jwk", key);
let out = JSON.stringify(keyout); let out = JSON.stringify(keyout);
if (dotenv) { if (dotenv){
out = [`SECRET_KEY='${out}'`].join("\n"); out = [`SECRET_KEY='${out}'`].join("\n");
} }
if (file) { if (file){
await Deno.writeTextFile(file, out); await Deno.writeTextFile(file, out);
} else { } else {
console.log(out); console.log(out);
} }
}); });
if (import.meta.main) { if ( import.meta.main ){
await key_out_cmd.parse(Deno.args); await key_out_cmd.parse(Deno.args);
} }

61
main.ts
View File

@ -4,19 +4,14 @@
/// <reference lib="dom.asynciterable" /> /// <reference lib="dom.asynciterable" />
/// <reference lib="deno.ns" /> /// <reference lib="deno.ns" />
import { import { PluginRenderResult, Plugin, ServerContext, Manifest, StartOptions } from "$fresh/server.ts";
Manifest,
Plugin,
PluginRenderResult,
ServerContext,
StartOptions,
} from "$fresh/server.ts";
import manifest from "./fresh.gen.ts"; import manifest from "./fresh.gen.ts";
import twindPlugin from "$fresh/plugins/twind.ts"; import twindPlugin from "$fresh/plugins/twind.ts";
import twindConfig from "./twind.config.ts"; import twindConfig from "./twind.config.ts";
import "https://deno.land/std@0.170.0/dotenv/load.ts"; import "https://deno.land/std@0.170.0/dotenv/load.ts";
import { Command } from "https://deno.land/x/cliffy@v0.25.6/mod.ts"; import { Command } from "https://deno.land/x/cliffy@v0.25.6/mod.ts";
import { fromFileUrl, join } from "path/mod.ts"; import { fromFileUrl, join } from "path/mod.ts";
import { prepareSecretKey } from "./util/secret.ts"; import { prepareSecretKey } from "./util/secret.ts";
@ -24,27 +19,24 @@ import { serve } from "http/server.ts";
import { user_command } from "./user.ts"; import { user_command } from "./user.ts";
import { key_out_cmd } from "./keyout.ts"; import { key_out_cmd } from "./keyout.ts";
import { prepareDocs } from "./src/store/doc.ts";
const github_markdown = await Deno.readTextFile( const github_markdown= await Deno.readTextFile(join(fromFileUrl(import.meta.url), "..", "static", "github-markdown.css"))
join(fromFileUrl(import.meta.url), "..", "static", "github-markdown.css"),
);
const CSSPlugin: Plugin = { const CSSPlugin: Plugin = {
name: "css plugin", name:"css plugin",
// deno-lint-ignore require-await // deno-lint-ignore require-await
render(ctx): PluginRenderResult { render(ctx): PluginRenderResult{
ctx.render(); ctx.render();
return { return {
styles: [{ styles: [{
cssText: github_markdown, cssText: github_markdown,
}], }]
}; }
}, }
}; };
await prepareSecretKey(); await prepareSecretKey();
async function startServer(manifest: Manifest, options: StartOptions = {}) { async function startServer(manifest: Manifest, options: StartOptions = {}){
const ctx = await ServerContext.fromManifest(manifest, options); const ctx = await ServerContext.fromManifest(manifest, options);
options.port ??= 8000; options.port ??= 8000;
@ -56,52 +48,43 @@ async function startServer(manifest: Manifest, options: StartOptions = {}) {
} }
} }
async function start( async function start({port = 8000, hostname = "localhost"}: {port?: number, hostname?: string} = {}){
{ port = 8000, hostname = "localhost" }: { await startServer(manifest, { plugins: [twindPlugin(twindConfig), CSSPlugin],
port?: number;
hostname?: string;
} = {},
) {
await startServer(manifest, {
plugins: [twindPlugin(twindConfig), CSSPlugin],
port: port, port: port,
hostname: hostname, hostname: hostname,
}); });
} }
if (import.meta.main) { if (import.meta.main){
const cmd = new Command(); const cmd = new Command();
cmd.name("fs-server") cmd.name("fs-server")
.description( .description("A simple file server that supports search, upload, and download.")
"A simple file server that supports search, upload, and download.",
)
.version("0.0.1") .version("0.0.1")
.globalOption("-d, --debug", "Enable debug mode.") .globalOption("-d, --debug", "Enable debug mode.")
.command("start", "Start the server.") .command("start", "Start the server.")
.option("-p, --port <port:number>", "The port to listen on.", { .option("-p, --port <port:number>", "The port to listen on.",
default: 8000, { default: 8000 })
})
.option("--auth", "Enable authentication.") .option("--auth", "Enable authentication.")
.arguments("[hostname:string]") .arguments("[hostname:string]")
.action(async ({ debug, port, auth }, hostname) => { .action(async ({debug, port, auth }, hostname) => {
hostname ??= "localhost"; hostname ??= "localhost";
if (auth) { if (auth){
Deno.env.set("AUTH_REQUIRED", "true"); Deno.env.set("AUTH_REQUIRED", "true");
} }
if (debug) { if (debug){
console.log("Debug mode enabled."); console.log("Debug mode enabled.");
} }
await prepareDocs();
await start({ await start({
port: port, port: port,
hostname: hostname, hostname: hostname,
}); });
}) }
)
.command("user", user_command) .command("user", user_command)
.command("keyout", key_out_cmd); .command("keyout", key_out_cmd);
await cmd.parse(Deno.args); await cmd.parse(Deno.args);
} else { }
await prepareDocs(); else {
await start(); await start();
} }

15
routes/_middleware.ts
View File

@ -1,21 +1,20 @@
import { MiddlewareHandlerContext } from "$fresh/server.ts"; import { MiddlewareHandlerContext } from "$fresh/server.ts";
import { getCookies } from "http/cookie.ts"; import { getCookies } from "http/cookie.ts";
import { verify } from "djwt"; import { decode, verify } from "djwt";
import { prepareSecretKey } from "../util/secret.ts"; import { prepareSecretKey } from "../util/secret.ts";
const secret_key = await prepareSecretKey(); const secret_key = await prepareSecretKey();
export const handler = async ( export const handler =
req: Request, async (req: Request , ctx: MiddlewareHandlerContext<Record<string, unknown>>) => {
ctx: MiddlewareHandlerContext<Record<string, unknown>>,
) => {
const cookies = getCookies(req.headers); const cookies = getCookies(req.headers);
const jwt = cookies["auth"]; const jwt = cookies["auth"];
try { try{
const payload = await verify(jwt, secret_key); const payload = await verify(jwt, secret_key);
ctx.state["login"] = payload; ctx.state["login"] = payload;
} catch (e) { }
catch (e){
ctx.state["login"] = null; ctx.state["login"] = null;
} }
return await ctx.next(); return await ctx.next();
}; }

32
routes/api/login.ts
View File

@ -6,6 +6,7 @@ import { getUser, verifyUser } from "../../src/user/user.ts";
import { create as createJWT } from "djwt"; import { create as createJWT } from "djwt";
import { prepareSecretKey } from "../../util/secret.ts"; import { prepareSecretKey } from "../../util/secret.ts";
const SECRET_KEY = await prepareSecretKey(); const SECRET_KEY = await prepareSecretKey();
async function POST(req: Request, ctx: HandlerContext): Promise<Response> { async function POST(req: Request, ctx: HandlerContext): Promise<Response> {
@ -13,14 +14,14 @@ async function POST(req: Request, ctx: HandlerContext): Promise<Response> {
const form = await req.formData(); const form = await req.formData();
const username = form.get("username"); const username = form.get("username");
const password = form.get("password"); const password = form.get("password");
if (username && password) { if (username && password){
const DB = connectDB(); const DB = connectDB();
const user = await getUser(DB, username.toString()); const user = await getUser(DB, username.toString());
if (user) { if (user){
if (await verifyUser(user, password.toString())) { if (await verifyUser(user, password.toString())){
const headers = new Headers(); const headers = new Headers();
const jwt = await createJWT({ alg: "HS512", typ: "JWT" }, { const jwt = await createJWT({alg:"HS512", typ: "JWT"},{
username: user.name, username: user.name
}, SECRET_KEY); }, SECRET_KEY);
setCookie(headers, { setCookie(headers, {
name: "auth", name: "auth",
@ -30,20 +31,19 @@ async function POST(req: Request, ctx: HandlerContext): Promise<Response> {
maxAge: 60 * 60 * 24 * 7, maxAge: 60 * 60 * 24 * 7,
domain: url.hostname, domain: url.hostname,
path: "/", path: "/",
secure: url.protocol === "https:", secure: url.protocol === "https:"
}); });
headers.set("Location", "/"); headers.set("Location", "/");
return new Response(null, { return new Response(null,{
status: Status.SeeOther, // See Other status: Status.SeeOther, // See Other
headers: headers, headers: headers
}); });
} }
} }
} }
return new Response( return new Response(`<!DOCTYPE html><html>
`<!DOCTYPE html><html>
<head> <title> Login Failed </title> </head> <head> <title> Login Failed </title> </head>
<body> <body>
<h1> Login Failed </h1> <h1> Login Failed </h1>
@ -52,16 +52,14 @@ async function POST(req: Request, ctx: HandlerContext): Promise<Response> {
document.location.href = "/login"; document.location.href = "/login";
</script> </script>
</body> </body>
</html>`, </html>`, {
{ headers:{
headers: { "Content-Type": "text/html"
"Content-Type": "text/html",
}, },
status: Status.Forbidden, status: Status.Forbidden,
}, });
);
} }
export const handler = { export const handler = {
POST, POST
}; };

52
routes/dir/[...path].tsx
View File

@ -1,6 +1,6 @@
import { HandlerContext, Handlers, PageProps } from "$fresh/server.ts"; import { PageProps, Handlers, HandlerContext } from "$fresh/server.ts";
import { asset, Head } from "$fresh/runtime.ts"; import { Head, asset } from "$fresh/runtime.ts";
import { removePrefixFromPathname } from "../../util/util.ts"; import {removePrefixFromPathname} from "../../util/util.ts";
import { join } from "path/posix.ts"; import { join } from "path/posix.ts";
import DirList, { EntryInfo } from "../../islands/DirList.tsx"; import DirList, { EntryInfo } from "../../islands/DirList.tsx";
import FileViewer from "../../islands/FileViewer.tsx"; import FileViewer from "../../islands/FileViewer.tsx";
@ -10,77 +10,73 @@ type DirProps = {
path: string; path: string;
stat: Deno.FileInfo; stat: Deno.FileInfo;
files: EntryInfo[]; files: EntryInfo[];
}; }
type FileProps = { type FileProps = {
type: "file"; type: "file";
path: string; path: string;
stat: Deno.FileInfo; stat: Deno.FileInfo;
}; }
type DirOrFileProps = DirProps | FileProps; type DirOrFileProps = DirProps | FileProps;
async function GET(req: Request, ctx: HandlerContext): Promise<Response> { async function GET(req: Request, ctx: HandlerContext): Promise<Response>{
const authRequired = Deno.env.get("AUTH_REQUIRED") === "true"; const authRequired = Deno.env.get("AUTH_REQUIRED") === "true";
if (authRequired) { if (authRequired) {
const login = ctx.state["login"]; const login = ctx.state["login"];
if (!login) { if (!login) {
return new Response(null, { return new Response(null, {
status: 302, status: 401,
headers: { headers: {
"Location": "/login",
"content-type": "text/plain", "content-type": "text/plain",
"Access-Control-Allow-Origin": "*", "Access-Control-Allow-Origin": "*",
"Access-Control-Allow-Methods": "GET,HEAD,PUT,PATCH,POST,DELETE", "Access-Control-Allow-Methods": "GET,HEAD,PUT,PATCH,POST,DELETE",
"Access-Control-Allow-Headers": "Access-Control-Allow-Headers": "Content-Type, Access-Control-Allow-Headers, Authorization, X-Requested-With"
"Content-Type, Access-Control-Allow-Headers, Authorization, X-Requested-With", }
},
}); });
} }
} }
const url = new URL(req.url); const url = new URL(req.url);
const path = removePrefixFromPathname(decodeURI(url.pathname), "/dir"); const path = removePrefixFromPathname(decodeURI(url.pathname), "/dir");
const stat = await Deno.stat(path); const stat = await Deno.stat(path);
if (stat.isDirectory) { if (stat.isDirectory){
const filesIter = await Deno.readDir(path); const filesIter = await Deno.readDir(path);
const files: EntryInfo[] = []; const files: EntryInfo[] = []
for await (const file of filesIter) { for await (const file of filesIter){
const fileStat = await Deno.stat(join(path, file.name)); const fileStat = await Deno.stat(join(path, file.name));
files.push({ files.push({
...file, ...file,
lastModified: fileStat.mtime ? new Date(fileStat.mtime) : undefined, lastModified: fileStat.mtime ? new Date(fileStat.mtime) : undefined,
size: fileStat.size, size: fileStat.size
}); });
} }
return await ctx.render({ return await ctx.render({
type: "dir", type: "dir",
stat, stat,
files, files
path, , path
}); })
} else { }
else{
return await ctx.render({ return await ctx.render({
type: "file", type: "file",
stat, stat, path
path,
}); });
} }
} }
export const handler: Handlers = { export const handler: Handlers = {
GET, GET
}; }
export default function DirLists(props: PageProps<DirOrFileProps>) { export default function DirLists(props: PageProps<DirOrFileProps>) {
const data = props.data; const data = props.data;
return ( return (<>
<>
<Head> <Head>
<title>Simple file server : {data.path}</title> <title>Simple file server : {data.path}</title>
</Head> </Head>
<div class="p-4 mx-auto max-w-screen-md"> <div class="p-4 mx-auto max-w-screen-md">
{data.type === "dir" {data.type === "dir" ? (<DirList path={data.path} files={data.files}></DirList>) :
? <DirList path={data.path} files={data.files}></DirList> (<FileViewer path={data.path}></FileViewer>)}
: <FileViewer path={data.path}></FileViewer>}
</div> </div>
</> </>
); );

27
routes/doc/index.tsx
View File

@ -1,37 +1,20 @@
import { Head } from "$fresh/runtime.ts"; import { Head } from "$fresh/runtime.ts";
import { HandlerContext, Handlers, PageProps } from "$fresh/server.ts"; import { PageProps, Handlers, HandlerContext } from "$fresh/server.ts";
import DocSearch from "../../islands/DocSearch.tsx"; import DocSearch from "../../islands/DocSearch.tsx";
import { Doc } from "../../src/collect.ts"; import { Doc } from "../../src/collect.ts";
import { docCollector } from "../../src/store/doc.ts"; import { docCollector } from "../../src/store/doc.ts";
async function GET(req: Request, ctx: HandlerContext): Promise<Response> { async function GET(req: Request, ctx: HandlerContext): Promise<Response> {
const authRequired = Deno.env.get("AUTH_REQUIRED") === "true";
if (authRequired) {
const login = ctx.state["login"];
if (!login) {
return new Response(null, {
status: 302,
headers: {
"Location": "/login",
"content-type": "text/plain",
"Access-Control-Allow-Origin": "*",
"Access-Control-Allow-Methods": "GET,HEAD,PUT,PATCH,POST,DELETE",
"Access-Control-Allow-Headers":
"Content-Type, Access-Control-Allow-Headers, Authorization, X-Requested-With",
},
});
}
}
const docs = docCollector.getDocs(); const docs = docCollector.getDocs();
return await ctx.render({ docs }); return await ctx.render({docs});
} }
export const handler: Handlers = { export const handler: Handlers = {
GET, GET,
}; }
export default function Docs(props: PageProps<{ docs: Doc[] }>) { export default function Docs(props: PageProps<{docs:Doc[]}>) {
const { docs } = props.data; const {docs} = props.data;
return ( return (
<> <>
<Head> <Head>

56
routes/fs/[...path].ts
View File

@ -1,11 +1,8 @@
import { HandlerContext, Handlers } from "$fresh/server.ts"; import { HandlerContext, Handlers } from "$fresh/server.ts";
import { serveFile } from "http/file_server.ts"; import { serveFile } from "http/file_server.ts";
import { removePrefixFromPathname } from "../../util/util.ts"; import {removePrefixFromPathname} from "../../util/util.ts";
export async function GET( export async function GET(req: Request, ctx: HandlerContext): Promise<Response> {
req: Request,
ctx: HandlerContext,
): Promise<Response> {
const url = new URL(req.url); const url = new URL(req.url);
const path = removePrefixFromPathname(decodeURI(url.pathname), "/fs"); const path = removePrefixFromPathname(decodeURI(url.pathname), "/fs");
// if auth is required, check if the user is logged in. // if auth is required, check if the user is logged in.
@ -15,20 +12,19 @@ export async function GET(
const login = ctx.state["login"]; const login = ctx.state["login"];
if (!login) { if (!login) {
return new Response(null, { return new Response(null, {
status: 302, status: 401,
headers: { headers: {
"Location": "/login",
"content-type": "text/plain", "content-type": "text/plain",
"Access-Control-Allow-Origin": "*", "Access-Control-Allow-Origin": "*",
"Access-Control-Allow-Methods": "GET,HEAD,PUT,PATCH,POST,DELETE", "Access-Control-Allow-Methods": "GET,HEAD,PUT,PATCH,POST,DELETE",
"Access-Control-Allow-Headers": "Access-Control-Allow-Headers": "Content-Type, Access-Control-Allow-Headers, Authorization, X-Requested-With"
"Content-Type, Access-Control-Allow-Headers, Authorization, X-Requested-With", }
},
}); });
} }
} }
try { try{
const fileInfo = await Deno.stat(path); const fileInfo = await Deno.stat(path);
if (fileInfo.isDirectory) { if (fileInfo.isDirectory) {
// if index.html exists, serve it. // if index.html exists, serve it.
@ -36,38 +32,32 @@ export async function GET(
const indexPath = path + "/index.html"; const indexPath = path + "/index.html";
try { try {
await Deno.stat(indexPath); await Deno.stat(indexPath);
const res = await serveFile(req, indexPath); const res = await serveFile(req, indexPath)
return res; return res;
} catch (e) { } catch (e) {
if (e instanceof Deno.errors.NotFound) { if (e instanceof Deno.errors.NotFound) {
const list: Deno.DirEntry[] = []; const list: Deno.DirEntry[] = []
for await (const entry of Deno.readDir(path)) { for await (const entry of Deno.readDir(path)){
list.push(entry); list.push(entry);
} }
return new Response( return new Response(JSON.stringify(
JSON.stringify( list
list, ), {
), headers: { "content-type": "application/json",
{
headers: {
"content-type": "application/json",
"Access-Control-Allow-Origin": "*", "Access-Control-Allow-Origin": "*",
"Access-Control-Allow-Methods": "Access-Control-Allow-Methods": "GET,HEAD,PUT,PATCH,POST,DELETE",
"GET,HEAD,PUT,PATCH,POST,DELETE", "Access-Control-Allow-Headers": "Content-Type, Access-Control-Allow-Headers, Authorization, X-Requested-With"},
"Access-Control-Allow-Headers":
"Content-Type, Access-Control-Allow-Headers, Authorization, X-Requested-With",
},
status: 200, status: 200,
}, });
);
} }
} }
} }
const res = await serveFile(req, path, { const res = await serveFile(req, path, {
fileInfo, fileInfo
}); });
return res; return res;
} catch (e) { }
catch (e) {
if (e instanceof Deno.errors.NotFound) { if (e instanceof Deno.errors.NotFound) {
return new Response("Not Found", { return new Response("Not Found", {
status: 404, status: 404,
@ -77,6 +67,8 @@ export async function GET(
} }
} }
export const handler: Handlers = { export const handler: Handlers = {
GET, GET
}; }

3
routes/index.tsx
View File

@ -13,8 +13,7 @@ export default function Home() {
alt="the fresh logo: a sliced lemon dripping with juice" alt="the fresh logo: a sliced lemon dripping with juice"
/> />
<p class="my-6"> <p class="my-6">
This is a simple file server. It serves files from the{" "} This is a simple file server. It serves files from the <code>CWD</code>.
<code>CWD</code>.
</p> </p>
<a href="/dir/">Go To CWD</a> | <a href="/doc/">Doc</a> <a href="/dir/">Go To CWD</a> | <a href="/doc/">Doc</a>
<hr></hr> <hr></hr>

31
routes/login.tsx
View File

@ -15,38 +15,21 @@ export default function Login() {
class="w-32 h-32" class="w-32 h-32"
alt="the fresh logo: a sliced lemon dripping with juice" alt="the fresh logo: a sliced lemon dripping with juice"
/> />
<form <form action="/api/login" method="POST" class="flex flex-col gap-2 items-stretch">
action="/api/login"
method="POST"
class="flex flex-col gap-2 items-stretch"
>
<div class="flex gap-2 flex-wrap"> <div class="flex gap-2 flex-wrap">
<div class="basis-40 flex items-center flex-1"> <div class="basis-40 flex items-center flex-1">
<label for="username" class="w-20">Username</label> <label for="username" class="w-20">Username</label>
<input <input type="text" name="username" id="username"
type="text" class="border-b-2 focus:border-green-500 transition-colors flex-1" />
name="username"
id="username"
class="border-b-2 focus:border-green-500 transition-colors flex-1"
/>
</div> </div>
<div class="flex items-center flex-1"> <div class="flex items-center flex-1">
<label for="password" class="w-20">Password</label> <label for="password" class="w-20">Password</label>
<input <input type="password" name="password" id="password"
type="password" class="border-b-2 focus:border-green-500 transition-colors flex-1" />
name="password"
id="password"
class="border-b-2 focus:border-green-500 transition-colors flex-1"
/>
</div> </div>
</div> </div>
<button <button type="submit" class="bg-gray-400 p-2 rounded
type="submit" m-auto">Login</button>
class="bg-gray-400 p-2 rounded
m-auto"
>
Login
</button>
</form> </form>
</div> </div>
</div> </div>

50
search.ts
View File

@ -2,34 +2,34 @@ import { Command } from "https://deno.land/x/cliffy@v0.25.6/mod.ts";
import { Index } from "./src/client_search.ts"; import { Index } from "./src/client_search.ts";
import { Doc, DocCollector, loadDocuments } from "./src/collect.ts"; import { Doc, DocCollector, loadDocuments } from "./src/collect.ts";
export async function collectDocuments(path: string, out: string) { export async function collectDocuments(path: string, out: string){
const collector = new DocCollector({ summaryOnly: true, dropContent: true }); const collector = new DocCollector({ summaryOnly: true, dropContent: true });
await collector.walkDir(path); await collector.walkDir(path);
const docs = collector.getDocs(); const docs = collector.getDocs();
await Deno.writeTextFile(out, JSON.stringify(docs)); await Deno.writeTextFile(out, JSON.stringify(docs));
} }
export async function watchDocuments(doc: string, options?: { export async function watchDocuments(doc: string , options?:{
abort?: AbortSignal; abort?: AbortSignal,
}) { }){
const doc_dump = await loadDocuments(doc); const doc_dump = await loadDocuments(doc);
const collector = new DocCollector({ summaryOnly: true, dropContent: true }); const collector = new DocCollector({ summaryOnly: true, dropContent: true });
collector.setDocs(doc_dump); collector.setDocs(doc_dump);
const index = Index.createIndex(doc_dump); const index = Index.createIndex(doc_dump);
async function update() { async function update(){
index.setDocs(collector.getDocs()); index.setDocs(collector.getDocs());
await Deno.writeTextFile(doc, JSON.stringify(collector.getDocs())); await Deno.writeTextFile(doc, JSON.stringify(collector.getDocs()));
} }
collector.watchDir(".", { collector.watchDir(".", {
async onAdd(doc) { async onAdd(doc){
console.log("onAdd :", doc.path); console.log("onAdd :", doc.path);
await update(); await update();
}, },
async onRemove(path) { async onRemove(path){
console.log("onRemove :", path); console.log("onRemove :", path);
await update(); await update();
}, },
async onChange(doc) { async onChange(doc){
console.log("onModify :", doc.path); console.log("onModify :", doc.path);
await update(); await update();
}, },
@ -40,45 +40,39 @@ export async function watchDocuments(doc: string, options?: {
export const search = new Command(); export const search = new Command();
search.name("search") search.name("search")
.description("Search for a document.") .description("Search for a document.")
.command("collect", "Collect a document.") .command("collect", "Collect a document.")
.description("Collect documents and index documents.") .description("Collect documents and index documents.")
.arguments("<path:string>") .arguments("<path:string>")
.option("-o, --out <path:string>", "out file to write the index to.", { .option("-o, --out <path:string>", "out file to write the index to.", {default: "collected_docs.json"})
default: "collected_docs.json", .action(async ({out} ,path: string) => {
})
.action(async ({ out }, path: string) => {
console.log("collecting", path); console.log("collecting", path);
await collectDocuments(path, out); await collectDocuments(path, out);
}) })
.command("search", "Search for a document.") .command("search", "Search for a document.")
.description("Search for a document.") .description("Search for a document.")
.arguments("<query:string>") .arguments("<query:string>")
.option("-d, --docs <path:string>", "collected document file to search", { .option("-d, --docs <path:string>", "collected document file to search", {default: "collected_docs.json"})
default: "collected_docs.json", .action(async ({docs}, query: string) => {
})
.action(async ({ docs }, query: string) => {
console.log("searching", query); console.log("searching", query);
const doc_dump = await loadDocuments(docs); const doc_dump = await loadDocuments(docs);
const results = Index.createIndex(doc_dump).search(query); const results = Index.createIndex(doc_dump).search(query);
console.log(results); console.log(results);
}) })
.command("interact", "watch the index and search for a document.") .command("interact", "watch the index and search for a document.")
.description("watch the index and search for a document.") .description("watch the index and search for a document.")
.option("-d, --doc <path:string>", "doc file to read the docs from.", { .option("-d, --doc <path:string>", "doc file to read the docs from.", {default: "collected_docs.json"})
default: "collected_docs.json", .action(async ({doc}) => {
})
.action(async ({ doc }) => {
console.log("interacting"); console.log("interacting");
const index = await watchDocuments(doc); const index = await watchDocuments(doc);
// interact // interact
while (true) { while (true){
const query = await prompt("query: "); const query = await prompt("query: ");
if (query === null) { if (query === null){
continue; continue;
} }
if (query === ":exit") { if (query === ":exit"){
break; break;
} }
const results = index.search(query); const results = index.search(query);
@ -86,6 +80,6 @@ search.name("search")
} }
}); });
if (import.meta.main) { if ( import.meta.main ){
await search.parse(Deno.args); await search.parse(Deno.args);
} }

31
src/client_search.ts
View File

@ -1,37 +1,30 @@
//// @deno-types="https://deno.land/x/fuse@v6.4.1/dist/fuse.d.ts" //// @deno-types="https://deno.land/x/fuse@v6.4.1/dist/fuse.d.ts"
import Fuse from "https://deno.land/x/fuse@v6.4.1/dist/fuse.esm.min.js"; import Fuse from 'https://deno.land/x/fuse@v6.4.1/dist/fuse.esm.min.js';
import { Doc } from "./collect.ts"; import { Doc } from "./collect.ts";
export class Index { export class Index{
private index: Fuse; private index: Fuse;
private constructor(index: Fuse) { private constructor(index: Fuse){
this.index = index; this.index = index;
} }
public setDocs(docs: Doc[]) { public setDocs(docs: Doc[]){
this.index.setCollection(docs); this.index.setCollection(docs);
} }
public search(query: string): Doc[] { public search(query: string): Doc[]{
return this.index.search(query, { limit: 10 }).map(( return this.index.search(query, {limit: 10}).map((
result, result) =>
) => result.item as Doc); result.item as Doc);
} }
public static createIndex(docs: Doc[]) { public static createIndex(docs: Doc[]){
const index = new Fuse(docs, { const index = new Fuse(docs,{
keys: [ keys: ["attributes.title", "attributes.japanese_title", "attributes.tags", "attributes.rjcode", "attributes.author", "path"],
"attributes.title",
"attributes.japanese_title",
"attributes.tags",
"attributes.rjcode",
"attributes.author",
"path",
],
includeScore: true, includeScore: true,
includeMatches: true, includeMatches: true,
}); })
return new Index(index); return new Index(index);
} }

138
src/collect.ts
View File

@ -1,8 +1,8 @@
import { basename, extname, join, relative } from "path/mod.ts"; import {join, extname, relative, basename} from "path/mod.ts";
import { readMarkdownDoc } from "./readDoc.ts"; import { readMarkdownDoc } from "./readDoc.ts";
import { Index } from "./client_search.ts"; import { Index } from "./client_search.ts";
export interface Doc { export interface Doc{
path: string; path: string;
content: string; content: string;
attributes: { attributes: {
@ -14,65 +14,65 @@ export interface Doc {
}; };
} }
export async function loadDocuments(path: string): Promise<Doc[]> { export async function loadDocuments(path: string): Promise<Doc[]>{
const doc_json = await Deno.readTextFile(path); const doc_json = await Deno.readTextFile(path);
return JSON.parse(doc_json) as Doc[]; return JSON.parse(doc_json) as Doc[];
} }
export interface DocCollectorOptions { export interface DocCollectorOptions{
summaryOnly?: boolean; summaryOnly?: boolean;
dropContent?: boolean; dropContent?: boolean;
} }
export class DocCollector { export class DocCollector {
private doc_map: Map<string, Doc>; private doc_map: Map<string,Doc>;
private options: DocCollectorOptions; private options: DocCollectorOptions;
constructor(options: DocCollectorOptions = {}) { constructor(options: DocCollectorOptions = {}){
this.doc_map = new Map(); this.doc_map = new Map();
this.options = options; this.options = options;
} }
public getDocs(): Doc[] { public getDocs(): Doc[]{
return [...this.doc_map.values()]; return [...this.doc_map.values()];
} }
public setDoc(doc: Doc) { public setDoc(doc: Doc){
if (this.options.dropContent) { if (this.options.dropContent){
doc.content = ""; doc.content = "";
} }
this.doc_map.set(doc.path, doc); this.doc_map.set(doc.path,doc);
} }
public setDocs(docs: Doc[]) { public setDocs(docs: Doc[]){
for (const doc of docs) { for (const doc of docs){
this.setDoc(doc); this.setDoc(doc);
} }
} }
public removeDoc(path: string) { public removeDoc(path: string){
this.doc_map.delete(path); this.doc_map.delete(path);
} }
public async walkDir(path: string) { public async walkDir(path: string){
const dir = Deno.readDir(path); const dir = Deno.readDir(path);
const fileList = []; const fileList = [];
for await (const entry of dir) { for await (const entry of dir){
fileList.push(entry); fileList.push(entry);
} }
if (fileList.some((entry) => entry.name === "SUMMARY.md")) { if (fileList.some((entry) => entry.name === "SUMMARY.md")){
const { content, metadata } = await readMarkdownDoc( const {content, metadata} = await readMarkdownDoc(join(path, "SUMMARY.md"));
join(path, "SUMMARY.md"),
);
this.setDoc({ this.setDoc({
path: join(path, "SUMMARY.md"), path: join(path, "SUMMARY.md"),
content: content, content: content,
attributes: metadata, attributes: metadata,
}); });
} else { }
for (const entry of fileList) { else {
if (entry.isDirectory) { for (const entry of fileList){
if (entry.isDirectory){
await this.walkDir(join(path, entry.name)); await this.walkDir(join(path, entry.name));
} else if (entry.isFile && !this.options.summaryOnly) { }
else if (entry.isFile && !this.options.summaryOnly){
const doc = await this.readDoc(join(path, entry.name)); const doc = await this.readDoc(join(path, entry.name));
this.setDoc(doc); this.setDoc(doc);
} }
@ -80,93 +80,95 @@ export class DocCollector {
} }
} }
public async readDoc(path: string): Promise<Doc> { public async readDoc(path: string): Promise<Doc>{
const ext = extname(path); const ext = extname(path);
if (ext === ".md") { if (ext === ".md"){
return await this.readMarkdown(path); return await this.readMarkdown(path);
} else if (ext === ".html" || ext === ".htm" || ext === ".xhtml") { }
else if (ext === ".html" || ext === ".htm" || ext === ".xhtml"){
return await this.readHTML(path); return await this.readHTML(path);
} else if (ext === ".txt") { }
else if (ext === ".txt"){
return await this.readText(path); return await this.readText(path);
} else { }
else {
return { return {
path: path, path: path,
content: "", content: "",
attributes: {}, attributes: {}
}; }
} }
} }
public async readHTML(path: string): Promise<Doc> { public async readHTML(path: string): Promise<Doc>{
const content = await Deno.readTextFile(path); const content = await Deno.readTextFile(path);
return { return {
path: path, path: path,
content: content, content: content,
attributes: {}, attributes: {},
};
} }
public async readText(path: string): Promise<Doc> { }
public async readText(path: string): Promise<Doc>{
const content = await Deno.readTextFile(path); const content = await Deno.readTextFile(path);
return { return {
path: path, path: path,
content: content, content: content,
attributes: {}, attributes: {},
};
} }
public async readMarkdown(path: string): Promise<Doc> { }
const { content, metadata } = await readMarkdownDoc(path); public async readMarkdown(path: string): Promise<Doc>{
const {content, metadata} = await readMarkdownDoc(path);
return { return {
path: path, path: path,
content: content, content: content,
attributes: metadata, attributes: metadata,
}; }
} }
async watchDir(path: string, { async watchDir(path: string, {
onRemove = (_path: string) => {}, onRemove = (_path: string) => {},
onAdd = (_doc: Doc) => {}, onAdd = (_doc: Doc) => {},
onChange = (_doc: Doc) => {}, onChange = (_doc: Doc) => {},
abort = undefined, abort = undefined,
}: { }:{
onRemove?: (path: string) => void | Promise<void>; onRemove?: (path: string) => void | Promise<void>,
onAdd?: (doc: Doc) => void | Promise<void>; onAdd?: (doc: Doc) => void | Promise<void>,
onChange?: (doc: Doc) => void | Promise<void>; onChange?: (doc: Doc) => void | Promise<void>,
abort?: AbortSignal; abort?: AbortSignal,
}) { }){
const watcher = Deno.watchFs(path); const watcher = Deno.watchFs(path);
if (abort) { if (abort){
abort.addEventListener("abort", () => { abort.addEventListener("abort", () => {
watcher.close(); watcher.close();
}); });
} }
for await (const event of watcher) { for await (const event of watcher){
if ( if (event.kind === "access" || event.kind === "other" || event.kind === "any"){
event.kind === "access" || event.kind === "other" ||
event.kind === "any"
) {
continue; continue;
} }
if (event.paths.length === 0) { if (event.paths.length === 0){
continue; continue;
} }
for (const path of event.paths) { for (const path of event.paths){
const relpath = relative(Deno.cwd(), path); const relpath = relative(Deno.cwd(), path);
const filename = basename(relpath); const filename = basename(relpath);
if (filename === "SUMMARY.md") { if (filename === "SUMMARY.md"){
if (event.kind === "remove") { if( event.kind === "remove"){
this.doc_map.delete(relpath); this.doc_map.delete(relpath);
await onRemove(relpath); await onRemove(relpath);
} else if (event.kind === "create" || event.kind === "modify") { }
const { content, metadata } = await readMarkdownDoc(relpath); else if (event.kind === "create" || event.kind === "modify"){
const {content, metadata} = await readMarkdownDoc(relpath);
const doc = { const doc = {
path: relpath, path: relpath,
content: content, content: content,
attributes: metadata, attributes: metadata,
}; };
this.setDoc(doc); this.setDoc(doc);
if (event.kind === "create") { if (event.kind === "create"){
await onAdd(doc); await onAdd(doc);
} else if (event.kind === "modify") { }
else if (event.kind === "modify"){
await onChange(doc); await onChange(doc);
} }
} }
@ -175,30 +177,30 @@ export class DocCollector {
} }
} }
makeIndex(options?: { makeIndex(options? : {
onUpdate?: (() => void) | (() => Promise<void>); onUpdate?: (() => void) | (() => Promise<void>),
abort?: AbortSignal; abort?: AbortSignal,
watch?: boolean; watch?: boolean,
}) { }){
const opt = options ?? {}; const opt = options ?? {};
const index = Index.createIndex(this.getDocs()); const index = Index.createIndex(this.getDocs());
if (!opt.watch) { if (!opt.watch){
return index; return index;
} }
const update = async () => { const update = async () => {
index.setDocs(this.getDocs()); index.setDocs(this.getDocs());
if (opt.onUpdate) { if (opt.onUpdate){
await opt.onUpdate(); await opt.onUpdate();
} }
}; }
this.watchDir(".", { this.watchDir(".", {
async onAdd(_doc) { async onAdd(_doc){
await update(); await update();
}, },
async onRemove(_path) { async onRemove(_path){
await update(); await update();
}, },
async onChange(_doc) { async onChange(_doc){
await update(); await update();
}, },
abort: opt.abort, abort: opt.abort,

5
src/media.ts
View File

@ -1,3 +1,4 @@
const ICON_MAP: Record<string, string> = { const ICON_MAP: Record<string, string> = {
".pdf": "file-pdf", ".pdf": "file-pdf",
".zip": "file-zip", ".zip": "file-zip",
@ -52,8 +53,8 @@ const ICON_MAP: Record<string, string> = {
".tif": "file-image", ".tif": "file-image",
".webp": "file-image", ".webp": "file-image",
".psd": "file-image", ".psd": "file-image",
}; }
export function extToIcon(s: string): string { export function extToIcon(s: string): string{
return `/icon/${(ICON_MAP[s] ?? "file")}.svg`; return `/icon/${(ICON_MAP[s] ?? "file")}.svg`;
} }

19
src/readDoc.ts
View File

@ -1,13 +1,7 @@
import { import {parse as parseYaml, stringify} from "https://deno.land/std@0.170.0/encoding/yaml.ts";
parse as parseYaml,
stringify,
} from "https://deno.land/std@0.170.0/encoding/yaml.ts";
function trimSubstring(str: string, start: number, end: number) { function trimSubstring(str: string, start: number, end: number) {
while ( while (str[start] === ' ' || str[start] === '\t' || str[start] === '\r' || str[start] === '\n') {
str[start] === " " || str[start] === "\t" || str[start] === "\r" ||
str[start] === "\n"
) {
start++; start++;
} }
return str.substring(start, end); return str.substring(start, end);
@ -19,23 +13,24 @@ interface Doc {
} }
export function parse(content: string): Doc { export function parse(content: string): Doc {
if (!content.startsWith("---")) { if(!content.startsWith('---')){
return { return {
metadata: {}, metadata: {},
content: content, content: content,
};
} }
const index = content.indexOf("\n---", 3); }
const index = content.indexOf('\n---', 3);
const meta = content.substring(3, index); const meta = content.substring(3, index);
const c = trimSubstring(content, index + 4, content.length); const c = trimSubstring(content, index + 4, content.length);
const metadata = parseYaml(meta) as Record<string, string | string[]>; const metadata = parseYaml(meta) as Record<string, string | string[]>;
return { return {
metadata: metadata, metadata: metadata,
content: c, content: c,
}; }
} }
export async function readMarkdownDoc(path: string): Promise<Doc> { export async function readMarkdownDoc(path: string): Promise<Doc> {
const doc = await Deno.readTextFile(path); const doc = await Deno.readTextFile(path);
return parse(doc); return parse(doc);
} }

11
src/store/doc.ts
View File

@ -1,12 +1,12 @@
import { Index } from "../client_search.ts"; import { Index } from "../client_search.ts";
import { Doc, DocCollector } from "../collect.ts"; import { Doc, DocCollector } from "../collect.ts";
export const docCollector = new DocCollector( export const docCollector = new DocCollector(
{ {
dropContent: true, dropContent: true,
summaryOnly: true, summaryOnly: true,
}, });
);
export let docIndex: Index | undefined = undefined; export let docIndex: Index | undefined = undefined;
@ -15,7 +15,7 @@ export async function prepareDocs() {
if (!docPath) { if (!docPath) {
await docCollector.walkDir("."); await docCollector.walkDir(".");
docIndex = docCollector.makeIndex({ docIndex = docCollector.makeIndex({
watch: true, watch: true
}); });
return docIndex; return docIndex;
} }
@ -28,7 +28,8 @@ export async function prepareDocs() {
if (error instanceof Deno.errors.NotFound) { if (error instanceof Deno.errors.NotFound) {
await docCollector.walkDir("."); await docCollector.walkDir(".");
await Deno.writeTextFile(docPath, JSON.stringify(docCollector.getDocs())); await Deno.writeTextFile(docPath, JSON.stringify(docCollector.getDocs()));
} else { }
else {
throw error; throw error;
} }
} }
@ -37,7 +38,7 @@ export async function prepareDocs() {
watch: true, watch: true,
onUpdate: async () => { onUpdate: async () => {
await Deno.writeTextFile(docPath, JSON.stringify(docCollector.getDocs())); await Deno.writeTextFile(docPath, JSON.stringify(docCollector.getDocs()));
}, }
}); });
return docIndex; return docIndex;
} }

6
src/user/db.ts
View File

@ -1,9 +1,9 @@
import { DB } from "sqlite"; import {DB} from 'sqlite';
import { createSchema } from "./user.ts"; import {createSchema} from './user.ts';
export function connectDB(): DB { export function connectDB(): DB {
let DB_path = Deno.env.get("DB_PATH"); let DB_path = Deno.env.get("DB_PATH");
if (DB_path === undefined) { if (DB_path === undefined){
Deno.env.set("DB_PATH", "./db.sqlite"); Deno.env.set("DB_PATH", "./db.sqlite");
DB_path = "./db.sqlite"; DB_path = "./db.sqlite";
} }

57
src/user/user.ts
View File

@ -1,44 +1,41 @@
import { compare, genSalt, hash } from "bcrypt"; import {genSalt, hash, compare} from "bcrypt";
import { DB } from "sqlite"; import { DB } from "sqlite";
interface User { interface User{
name: string; name: string;
salted_password: string; salted_password: string;
salt: string; salt: string;
} }
export async function createUser(name: string, password: string) { export async function createUser(name: string, password: string){
const salt = await genSalt(10); const salt = await genSalt(10);
const salted_password = await hash(password, salt); const salted_password = await hash(password, salt);
const user: User = { const user: User = {
name: name, name: name,
salted_password: salted_password, salted_password: salted_password,
salt: salt, salt: salt
}; }
return user; return user;
} }
export async function verifyUser(user: User, password: string) { export async function verifyUser(user: User, password: string){
return await compare(password, user.salted_password); return await compare(password, user.salted_password);
} }
export async function getAllUsers(db: DB): Promise<User[]> { export async function getAllUsers(db :DB): Promise<User[]>{
const users = await db.query<[string, string, string]>( const users = await db.query<[string, string, string]>
"SELECT name, salted_password, salt FROM users", ("SELECT name, salted_password, salt FROM users");
); return users.map(([name, salted_password, salt])=>({
return users.map(([name, salted_password, salt]) => ({
name, name,
salted_password, salted_password,
salt, salt,
})); }));
} }
export async function getUser(db: DB, name: string): Promise<User | undefined> { export async function getUser(db: DB, name: string): Promise<User | undefined>{
const users = await db.query<[string, string, string]>( const users = await db.query<[string, string, string]>
"SELECT name, salted_password, salt FROM users WHERE name = ?", ("SELECT name, salted_password, salt FROM users WHERE name = ?", [name]);
[name], if (users === undefined || users.length === 0){
);
if (users === undefined || users.length === 0) {
return undefined; return undefined;
} }
const user = users[0]; const user = users[0];
@ -46,29 +43,23 @@ export async function getUser(db: DB, name: string): Promise<User | undefined> {
name: user[0], name: user[0],
salted_password: user[1], salted_password: user[1],
salt: user[2], salt: user[2],
}; }
} }
export async function addUser(db: DB, user: User) { export async function addUser(db: DB, user: User){
await db.query( await db.query("INSERT INTO users (name, salted_password, salt) VALUES (?, ?, ?)",
"INSERT INTO users (name, salted_password, salt) VALUES (?, ?, ?)", [user.name, user.salted_password, user.salt]);
[user.name, user.salted_password, user.salt],
);
} }
export async function updateUser(db: DB, user: User) { export async function updateUser(db: DB, user: User){
await db.query( await db.query("UPDATE users SET salted_password = ?, salt = ? WHERE name = ?",
"UPDATE users SET salted_password = ?, salt = ? WHERE name = ?", [user.salted_password, user.salt, user.name]);
[user.salted_password, user.salt, user.name],
);
} }
export async function deleteUser(db: DB, name: string) { export async function deleteUser(db: DB, name: string){
await db.query("DELETE FROM users WHERE name = ?", [name]); await db.query("DELETE FROM users WHERE name = ?", [name]);
} }
export async function createSchema(db: DB) { export async function createSchema(db: DB){
await db.query( await db.query("CREATE TABLE IF NOT EXISTS users (name TEXT PRIMARY KEY, salted_password TEXT, salt TEXT)");
"CREATE TABLE IF NOT EXISTS users (name TEXT PRIMARY KEY, salted_password TEXT, salt TEXT)",
);
} }

2
tailwind.config.cjs
View File

@ -5,4 +5,4 @@ module.exports = {
extend: {}, extend: {},
}, },
plugins: [], plugins: [],
}; }

1
test_data/d/SUMMARY.md
View File

@ -2,7 +2,6 @@
title: "hello" title: "hello"
tags: ["asdf","wer"] tags: ["asdf","wer"]
--- ---
# hello # hello
- [hello](hello.md) - [hello](hello.md)

6
test_data/e/SUMMARY.md
View File

@ -3,12 +3,8 @@ rjcode: RJ130512
title: Summary of the 13th Meeting of the Joint Committee on the Safety of Nuclear Installations title: Summary of the 13th Meeting of the Joint Committee on the Safety of Nuclear Installations
tags: ["summary", "meeting", "joint committee", "safety", "nuclear installations"] tags: ["summary", "meeting", "joint committee", "safety", "nuclear installations"]
--- ---
# Summary of the 13th Meeting of the Joint Committee on the Safety of Nuclear Installations # Summary of the 13th Meeting of the Joint Committee on the Safety of Nuclear Installations
## 1. Opening of the meeting ## 1. Opening of the meeting
The 13th meeting of the Joint Committee on the Safety of Nuclear Installations The 13th meeting of the Joint Committee on the Safety of Nuclear Installations (JCSNI) was held in Vienna on 12 May 2013. The meeting was chaired by Mr. J. M. Sánchez, Director of the Nuclear Safety Department of the Spanish Ministry of Industry, Energy and Tourism, and the Vice-Chairman of the JCSNI.
(JCSNI) was held in Vienna on 12 May 2013. The meeting was chaired by Mr. J. M.
Sánchez, Director of the Nuclear Safety Department of the Spanish Ministry of
Industry, Energy and Tourism, and the Vice-Chairman of the JCSNI.

4
test_data/한글/SUMMARY.md
View File

@ -1,4 +0,0 @@
---
title: "SUMMARY"
tags: ["SUMMARY"]
---

33
user.ts
View File

@ -1,8 +1,4 @@
import { import { Command, Input, Secret } from "https://deno.land/x/cliffy@v0.25.6/mod.ts";
Command,
Input,
Secret,
} from "https://deno.land/x/cliffy@v0.25.6/mod.ts";
import { connectDB } from "./src/user/db.ts"; import { connectDB } from "./src/user/db.ts";
import * as users from "./src/user/user.ts"; import * as users from "./src/user/user.ts";
@ -12,32 +8,33 @@ export const user_command = new Command()
.arguments("[username:string]") .arguments("[username:string]")
.option("-p, --password <password:string>", "The password for the user.") .option("-p, --password <password:string>", "The password for the user.")
.option("-q, --quiet", "quiet output.") .option("-q, --quiet", "quiet output.")
.action(async ({ quiet, password }, username) => { .action(async ({quiet, password}
if (username === undefined) { , username) => {
if(username === undefined){
username = await Input.prompt("Username: "); username = await Input.prompt("Username: ");
} }
if (password === undefined) { if(password === undefined){
password = await Secret.prompt("Password: "); password = await Secret.prompt("Password: ");
const password2 = await Secret.prompt("Confirm password: "); const password2 = await Secret.prompt("Confirm password: ");
if (password !== password2) { if (password !== password2){
console.error("Passwords do not match."); console.error("Passwords do not match.");
Deno.exit(1); Deno.exit(1);
} }
} }
const db = connectDB(); const db = connectDB();
const new_user = await users.createUser(username, password); const new_user = await users.createUser( username, password);
await users.addUser(db, new_user); await users.addUser(db, new_user);
if (!quiet) { if (!quiet){
console.log(`Added user ${username}`); console.log(`Added user ${username}`);
} }
}) })
.command("delete", "delete a user") .command("delete", "delete a user")
.arguments("<username:string>") .arguments("<username:string>")
.option("-q, --quiet", "Quiet output.") .option("-q, --quiet", "Quiet output.")
.action(async ({ quiet }, username) => { .action(async ({quiet}, username) => {
const db = connectDB(); const db = connectDB();
await users.deleteUser(db, username); await users.deleteUser(db, username);
if (!quiet) { if (!quiet){
console.log(`Deleting user ${username}`); console.log(`Deleting user ${username}`);
} }
}) })
@ -45,22 +42,22 @@ export const user_command = new Command()
.action(async () => { .action(async () => {
const db = connectDB(); const db = connectDB();
const all_users = await users.getAllUsers(db); const all_users = await users.getAllUsers(db);
for (const user of all_users) { for (const user of all_users){
console.log(`${user.name}`); console.log(`${user.name}`);
} }
}) })
.command("reset", "reset a user's password") .command("reset", "reset a user's password")
.arguments("<username:string> <password:string>") .arguments("<username:string> <password:string>")
.option("-q, --quiet", "quiet output.") .option("-q, --quiet", "quiet output.")
.action(async ({ quiet }, [username, password]) => { .action(async ({quiet}, [username, password]) => {
const db = connectDB(); const db = connectDB();
const new_user = await users.createUser(username, password); const new_user = await users.createUser( username, password);
await users.updateUser(db, new_user); await users.updateUser(db, new_user);
if (!quiet) { if (!quiet){
console.log(`Resetting password for user ${username}`); console.log(`Resetting password for user ${username}`);
} }
}); });
if (import.meta.main) { if (import.meta.main){
await user_command.parse(Deno.args); await user_command.parse(Deno.args);
} }

17
util/secret.ts
View File

@ -1,3 +1,4 @@
export async function generateSecretKey() { export async function generateSecretKey() {
const key = await crypto.subtle.generateKey( const key = await crypto.subtle.generateKey(
{ name: "HMAC", hash: "SHA-512" }, { name: "HMAC", hash: "SHA-512" },
@ -8,21 +9,17 @@ export async function generateSecretKey() {
return key; return key;
} }
export async function prepareSecretKey() { export async function prepareSecretKey(){
const key = Deno.env.get("SECRET_KEY"); const key = Deno.env.get("SECRET_KEY");
if (key) { if (key){
const jwk = JSON.parse(key) as JsonWebKey; const jwk = JSON.parse(key) as JsonWebKey;
{ {
const key = await crypto.subtle.importKey( const key = await crypto.subtle.importKey("jwk", jwk,
"jwk", { name: "HMAC", hash: "SHA-512" }, true, ["sign", "verify"]);
jwk,
{ name: "HMAC", hash: "SHA-512" },
true,
["sign", "verify"],
);
return key; return key;
} }
} else { }
else {
const key = await generateSecretKey(); const key = await generateSecretKey();
const out = await crypto.subtle.exportKey("jwk", key); const out = await crypto.subtle.exportKey("jwk", key);
Deno.env.set("SECRET_KEY", JSON.stringify(out)); Deno.env.set("SECRET_KEY", JSON.stringify(out));

5
util/util.ts
View File

@ -1,7 +1,4 @@
export function removePrefixFromPathname( export function removePrefixFromPathname(pathname: string, prefix: string): string {
pathname: string,
prefix: string,
): string {
let ret = pathname; let ret = pathname;
ret = ret.slice(prefix.length); ret = ret.slice(prefix.length);
if (ret.startsWith("/")) { if (ret.startsWith("/")) {