leaflet.pub
a tool for shared writing and social publishing
add subdomain to publications
awarm.space
+2
-6
actions/emailAuth.ts
+2
-6
actions/emailAuth.ts
···
7
import { and, eq } from "drizzle-orm";
8
import { cookies } from "next/headers";
9
import { createIdentity } from "./createIdentity";
10
11
async function sendAuthCode(email: string, code: string) {
12
if (process.env.NODE_ENV === "development") {
···
136
)
137
.returning();
138
139
-
(await cookies()).set("auth_token", confirmedToken.id, {
140
-
maxAge: 60 * 60 * 24 * 365,
141
-
secure: process.env.NODE_ENV === "production",
142
-
httpOnly: true,
143
-
sameSite: "lax",
144
-
});
145
146
client.end();
147
return confirmedToken;
···
7
import { and, eq } from "drizzle-orm";
8
import { cookies } from "next/headers";
9
import { createIdentity } from "./createIdentity";
10
+
import { setAuthToken } from "src/auth";
11
12
async function sendAuthCode(email: string, code: string) {
13
if (process.env.NODE_ENV === "development") {
···
137
)
138
.returning();
139
140
+
await setAuthToken(confirmedToken.id);
141
142
client.end();
143
return confirmedToken;
+5
-2
app/[leaflet_id]/Actions.tsx
+5
-2
app/[leaflet_id]/Actions.tsx
···
1
import { publishToPublication } from "actions/publishToPublication";
2
import { ActionButton } from "components/ActionBar/ActionButton";
3
import { ArrowRightTiny } from "components/Icons/ArrowRightTiny";
4
import { GoBackSmall } from "components/Icons/GoBackSmall";
···
11
import { useParams } from "next/navigation";
12
import { useBlocks } from "src/hooks/queries/useBlocks";
13
import { useEntity, useReplicache } from "src/replicache";
14
export const BackToPubButton = (props: {
15
publication: {
16
identity_did: string;
17
indexed_at: string;
18
name: string;
19
uri: string;
20
};
21
}) => {
···
25
let name = props.publication.name;
26
return (
27
<Link
28
-
href={`/lish/${handle}/${name}/dashboard`}
29
className="hover:!no-underline"
30
>
31
<ActionButton
···
64
<div>
65
{pub.doc ? "Updated! " : "Published! "}
66
<Link
67
-
href={`/lish/${pub.publications.identity_did}/${pub.publications.uri}/${doc?.rkey}`}
68
>
69
link
70
</Link>
···
1
import { publishToPublication } from "actions/publishToPublication";
2
+
import { getPublicationURL } from "app/lish/createPub/getPublicationURL";
3
import { ActionButton } from "components/ActionBar/ActionButton";
4
import { ArrowRightTiny } from "components/Icons/ArrowRightTiny";
5
import { GoBackSmall } from "components/Icons/GoBackSmall";
···
12
import { useParams } from "next/navigation";
13
import { useBlocks } from "src/hooks/queries/useBlocks";
14
import { useEntity, useReplicache } from "src/replicache";
15
+
import { Json } from "supabase/database.types";
16
export const BackToPubButton = (props: {
17
publication: {
18
identity_did: string;
19
indexed_at: string;
20
name: string;
21
+
record: Json;
22
uri: string;
23
};
24
}) => {
···
28
let name = props.publication.name;
29
return (
30
<Link
31
+
href={`${getPublicationURL(props.publication)}/dashboard`}
32
className="hover:!no-underline"
33
>
34
<ActionButton
···
67
<div>
68
{pub.doc ? "Updated! " : "Published! "}
69
<Link
70
+
href={`${getPublicationURL(pub.publications)}/${doc?.rkey}`}
71
>
72
link
73
</Link>
+3
-8
app/api/oauth/[route]/route.ts
+3
-8
app/api/oauth/[route]/route.ts
···
6
import { NextRequest, NextResponse } from "next/server";
7
import postgres from "postgres";
8
import { createOauthClient } from "src/atproto-oauth";
9
10
import { supabaseServerClient } from "supabase/serverClient";
11
···
14
};
15
export async function GET(
16
req: NextRequest,
17
-
props: { params: Promise<{ route: string; handle?: string }> }
18
) {
19
const params = await props.params;
20
let client = await createOauthClient();
···
89
.select()
90
.single();
91
92
-
if (token)
93
-
(await cookies()).set("auth_token", token.id, {
94
-
maxAge: 60 * 60 * 24 * 365,
95
-
secure: process.env.NODE_ENV === "production",
96
-
httpOnly: true,
97
-
sameSite: "lax",
98
-
});
99
100
// Process successful authentication here
101
console.log("authorize() was called with state:", state);
···
6
import { NextRequest, NextResponse } from "next/server";
7
import postgres from "postgres";
8
import { createOauthClient } from "src/atproto-oauth";
9
+
import { setAuthToken } from "src/auth";
10
11
import { supabaseServerClient } from "supabase/serverClient";
12
···
15
};
16
export async function GET(
17
req: NextRequest,
18
+
props: { params: Promise<{ route: string; handle?: string }> },
19
) {
20
const params = await props.params;
21
let client = await createOauthClient();
···
90
.select()
91
.single();
92
93
+
if (token) await setAuthToken(token.id);
94
95
// Process successful authentication here
96
console.log("authorize() was called with state:", state);
+11
-2
app/home/Publications.tsx
+11
-2
app/home/Publications.tsx
···
6
import { theme } from "tailwind.config";
7
import { BlueskyTiny } from "components/Icons/BlueskyTiny";
8
import { AddTiny } from "components/Icons/AddTiny";
9
10
export const MyPublicationList = () => {
11
let { identity } = useIdentityData();
···
31
identity_did: string;
32
indexed_at: string;
33
name: string;
34
uri: string;
35
}[];
36
}) => {
···
43
{...d}
44
key={d.uri}
45
handle={identity?.resolved_did?.alsoKnownAs?.[0].slice(5)!}
46
/>
47
))}
48
</div>
49
);
50
};
51
52
-
function Publication(props: { uri: string; name: string; handle: string }) {
53
return (
54
<Link
55
className="pubListItem w-full p-3 opaque-container rounded-lg! text-secondary text-center hover:no-underline flex flex-col gap-1 place-items-center transparent-outline outline-2 outline-offset-1 hover:outline-border basis-0 grow min-w-0"
56
-
href={`/lish/${props.handle}/${props.name}/dashboard`}
57
>
58
<div className="w-6 h-6 rounded-full bg-test" />
59
<h4 className="font-bold w-full truncate">{props.name}</h4>
···
6
import { theme } from "tailwind.config";
7
import { BlueskyTiny } from "components/Icons/BlueskyTiny";
8
import { AddTiny } from "components/Icons/AddTiny";
9
+
import { getPublicationURL } from "app/lish/createPub/getPublicationURL";
10
+
import { Json } from "supabase/database.types";
11
12
export const MyPublicationList = () => {
13
let { identity } = useIdentityData();
···
33
identity_did: string;
34
indexed_at: string;
35
name: string;
36
+
record: Json;
37
uri: string;
38
}[];
39
}) => {
···
46
{...d}
47
key={d.uri}
48
handle={identity?.resolved_did?.alsoKnownAs?.[0].slice(5)!}
49
+
record={d.record}
50
/>
51
))}
52
</div>
53
);
54
};
55
56
+
function Publication(props: {
57
+
uri: string;
58
+
name: string;
59
+
handle: string;
60
+
record: Json;
61
+
}) {
62
return (
63
<Link
64
className="pubListItem w-full p-3 opaque-container rounded-lg! text-secondary text-center hover:no-underline flex flex-col gap-1 place-items-center transparent-outline outline-2 outline-offset-1 hover:outline-border basis-0 grow min-w-0"
65
+
href={`${getPublicationURL(props)}/dashboard`}
66
>
67
<div className="w-6 h-6 rounded-full bg-test" />
68
<h4 className="font-bold w-full truncate">{props.name}</h4>
+12
-3
app/lish/PostList.tsx
+12
-3
app/lish/PostList.tsx
···
5
import { useIdentityData } from "components/IdentityProvider";
6
import { useParams } from "next/navigation";
7
import { AtUri } from "@atproto/syntax";
8
9
export const PostList = (props: {
10
isFeed?: boolean;
11
posts: {
12
documents: {
13
data: Json;
···
38
let uri = new AtUri(post.documents?.uri!);
39
40
return (
41
-
<PostListItem {...p} key={index} isFeed={props.isFeed} uri={uri} />
42
);
43
})}
44
</div>
···
47
48
const PostListItem = (
49
props: {
50
isFeed?: boolean;
51
uri: AtUri;
52
} & PubLeafletDocument.Record,
···
57
<div className="pubPostListItem flex flex-col">
58
{props.isFeed && (
59
<Link
60
-
href={`/lish/${identity?.resolved_did?.alsoKnownAs?.[0].slice(5)}/${props.publication}/`}
61
className="font-bold text-tertiary hover:no-underline text-sm "
62
>
63
{props.publication}
···
65
)}
66
67
<Link
68
-
href={`/lish/${params.handle}/${params.publication}/${props.uri.rkey}/`}
69
className="pubPostListContent flex flex-col hover:no-underline hover:text-accent-contrast"
70
>
71
<h4>{props.title}</h4>
···
5
import { useIdentityData } from "components/IdentityProvider";
6
import { useParams } from "next/navigation";
7
import { AtUri } from "@atproto/syntax";
8
+
import { getPublicationURL } from "./createPub/getPublicationURL";
9
10
export const PostList = (props: {
11
isFeed?: boolean;
12
+
publication: { uri: string; record: Json; name: string };
13
posts: {
14
documents: {
15
data: Json;
···
40
let uri = new AtUri(post.documents?.uri!);
41
42
return (
43
+
<PostListItem
44
+
{...p}
45
+
publication_data={props.publication}
46
+
key={index}
47
+
isFeed={props.isFeed}
48
+
uri={uri}
49
+
/>
50
);
51
})}
52
</div>
···
55
56
const PostListItem = (
57
props: {
58
+
publication_data: { uri: string; record: Json; name: string };
59
isFeed?: boolean;
60
uri: AtUri;
61
} & PubLeafletDocument.Record,
···
66
<div className="pubPostListItem flex flex-col">
67
{props.isFeed && (
68
<Link
69
+
href={getPublicationURL(props.publication_data)}
70
className="font-bold text-tertiary hover:no-underline text-sm "
71
>
72
{props.publication}
···
74
)}
75
76
<Link
77
+
href={`${getPublicationURL(props.publication_data)}/${props.uri.rkey}/`}
78
className="pubPostListContent flex flex-col hover:no-underline hover:text-accent-contrast"
79
>
80
<h4>{props.title}</h4>
+11
-9
app/lish/[handle]/[publication]/[rkey]/page.tsx
app/lish/[did]/[publication]/[rkey]/page.tsx
+11
-9
app/lish/[handle]/[publication]/[rkey]/page.tsx
app/lish/[did]/[publication]/[rkey]/page.tsx
···
1
import Link from "next/link";
2
-
import { IdResolver } from "@atproto/identity";
3
import { supabaseServerClient } from "supabase/serverClient";
4
import { AtUri } from "@atproto/syntax";
5
import { ids } from "lexicons/api/lexicons";
···
11
PubLeafletPagesLinearDocument,
12
} from "lexicons/api";
13
import { Metadata } from "next";
14
15
-
const idResolver = new IdResolver();
16
export async function generateMetadata(props: {
17
-
params: Promise<{ publication: string; handle: string; rkey: string }>;
18
}): Promise<Metadata> {
19
-
let did = await idResolver.handle.resolve((await props.params).handle);
20
if (!did) return { title: "Publication 404" };
21
22
let { data: document } = await supabaseServerClient
···
38
};
39
}
40
export default async function Post(props: {
41
-
params: Promise<{ publication: string; handle: string; rkey: string }>;
42
}) {
43
-
let did = await idResolver.handle.resolve((await props.params).handle);
44
if (!did) return <div> can't resolve handle</div>;
45
let { data: document } = await supabaseServerClient
46
.from("documents")
47
-
.select("*")
48
.eq(
49
"uri",
50
AtUri.make(did, ids.PubLeafletDocument, (await props.params).rkey),
51
)
52
.single();
53
-
if (!document?.data) return <div>notfound</div>;
54
let record = document.data as PubLeafletDocument.Record;
55
let firstPage = record.pages[0];
56
let blocks: PubLeafletPagesLinearDocument.Block[] = [];
···
64
<div className="flex flex-col pb-8">
65
<Link
66
className="font-bold hover:no-underline text-accent-contrast"
67
-
href={`/lish/${(await props.params).handle}/${(await props.params).publication}`}
68
>
69
{decodeURIComponent((await props.params).publication)}
70
</Link>
···
1
import Link from "next/link";
2
import { supabaseServerClient } from "supabase/serverClient";
3
import { AtUri } from "@atproto/syntax";
4
import { ids } from "lexicons/api/lexicons";
···
10
PubLeafletPagesLinearDocument,
11
} from "lexicons/api";
12
import { Metadata } from "next";
13
+
import { getPublicationURL } from "app/lish/createPub/getPublicationURL";
14
15
export async function generateMetadata(props: {
16
+
params: Promise<{ publication: string; did: string; rkey: string }>;
17
}): Promise<Metadata> {
18
+
let did = decodeURIComponent((await props.params).did);
19
if (!did) return { title: "Publication 404" };
20
21
let { data: document } = await supabaseServerClient
···
37
};
38
}
39
export default async function Post(props: {
40
+
params: Promise<{ publication: string; did: string; rkey: string }>;
41
}) {
42
+
let did = decodeURIComponent((await props.params).did);
43
if (!did) return <div> can't resolve handle</div>;
44
let { data: document } = await supabaseServerClient
45
.from("documents")
46
+
.select("*, documents_in_publications(publications(*))")
47
.eq(
48
"uri",
49
AtUri.make(did, ids.PubLeafletDocument, (await props.params).rkey),
50
)
51
.single();
52
+
if (!document?.data || !document.documents_in_publications[0].publications)
53
+
return <div>notfound</div>;
54
let record = document.data as PubLeafletDocument.Record;
55
let firstPage = record.pages[0];
56
let blocks: PubLeafletPagesLinearDocument.Block[] = [];
···
64
<div className="flex flex-col pb-8">
65
<Link
66
className="font-bold hover:no-underline text-accent-contrast"
67
+
href={getPublicationURL(
68
+
document.documents_in_publications[0].publications,
69
+
)}
70
>
71
{decodeURIComponent((await props.params).publication)}
72
</Link>
app/lish/[handle]/[publication]/dashboard/Actions.tsx
app/lish/[did]/[publication]/dashboard/Actions.tsx
app/lish/[handle]/[publication]/dashboard/Actions.tsx
app/lish/[did]/[publication]/dashboard/Actions.tsx
app/lish/[handle]/[publication]/dashboard/DraftList.tsx
app/lish/[did]/[publication]/dashboard/DraftList.tsx
app/lish/[handle]/[publication]/dashboard/DraftList.tsx
app/lish/[did]/[publication]/dashboard/DraftList.tsx
app/lish/[handle]/[publication]/dashboard/NewDraftButton.tsx
app/lish/[did]/[publication]/dashboard/NewDraftButton.tsx
app/lish/[handle]/[publication]/dashboard/NewDraftButton.tsx
app/lish/[did]/[publication]/dashboard/NewDraftButton.tsx
app/lish/[handle]/[publication]/dashboard/PublicationDashboard.tsx
app/lish/[did]/[publication]/dashboard/PublicationDashboard.tsx
app/lish/[handle]/[publication]/dashboard/PublicationDashboard.tsx
app/lish/[did]/[publication]/dashboard/PublicationDashboard.tsx
app/lish/[handle]/[publication]/dashboard/PublicationSWRProvider.tsx
app/lish/[did]/[publication]/dashboard/PublicationSWRProvider.tsx
app/lish/[handle]/[publication]/dashboard/PublicationSWRProvider.tsx
app/lish/[did]/[publication]/dashboard/PublicationSWRProvider.tsx
+2
-1
app/lish/[handle]/[publication]/dashboard/PublishedPostsLists.tsx
app/lish/[did]/[publication]/dashboard/PublishedPostsLists.tsx
+2
-1
app/lish/[handle]/[publication]/dashboard/PublishedPostsLists.tsx
app/lish/[did]/[publication]/dashboard/PublishedPostsLists.tsx
···
9
import { usePublicationData } from "./PublicationSWRProvider";
10
import { Fragment } from "react";
11
import { useParams } from "next/navigation";
12
13
export function PublishedPostsList() {
14
let publication = usePublicationData();
···
35
<div className="flex w-full ">
36
<Link
37
target="_blank"
38
-
href={`/lish/${params.handle}/${params.publication}/${uri.rkey}`}
39
className="publishedPost grow flex flex-col hover:!no-underline"
40
>
41
<h3 className="text-primary">{record.title}</h3>
···
9
import { usePublicationData } from "./PublicationSWRProvider";
10
import { Fragment } from "react";
11
import { useParams } from "next/navigation";
12
+
import { getPublicationURL } from "app/lish/createPub/getPublicationURL";
13
14
export function PublishedPostsList() {
15
let publication = usePublicationData();
···
36
<div className="flex w-full ">
37
<Link
38
target="_blank"
39
+
href={`${getPublicationURL(publication)}/${uri.rkey}`}
40
className="publishedPost grow flex flex-col hover:!no-underline"
41
>
42
<h3 className="text-primary">{record.title}</h3>
+7
-7
app/lish/[handle]/[publication]/dashboard/page.tsx
app/lish/[did]/[publication]/dashboard/page.tsx
+7
-7
app/lish/[handle]/[publication]/dashboard/page.tsx
app/lish/[did]/[publication]/dashboard/page.tsx
···
20
const idResolver = new IdResolver();
21
22
export async function generateMetadata(props: {
23
-
params: Promise<{ publication: string; handle: string }>;
24
}): Promise<Metadata> {
25
-
let did = await idResolver.handle.resolve((await props.params).handle);
26
if (!did) return { title: "Publication 404" };
27
28
let { result: publication } = await get_publication_data.handler(
···
38
39
//This is the admin dashboard of the publication
40
export default async function Publication(props: {
41
-
params: Promise<{ publication: string; handle: string }>;
42
}) {
43
let params = await props.params;
44
let identity = await getIdentityData();
45
-
if (!identity || !identity.atp_did) return <PubNotFound />;
46
-
let did = await idResolver.handle.resolve((await props.params).handle);
47
if (!did) return <PubNotFound />;
48
let { result: publication } = await get_publication_data.handler(
49
{
···
53
{ supabase: supabaseServerClient },
54
);
55
56
-
let record = publication?.record as PubLeafletPublication.Record;
57
if (!publication || identity.atp_did !== publication.identity_did)
58
return <PubNotFound />;
59
···
77
>
78
<PublicationDashboard
79
did={did}
80
-
icon={record.icon ? record.icon : null}
81
name={publication.name}
82
tabs={{
83
Drafts: <DraftList />,
···
20
const idResolver = new IdResolver();
21
22
export async function generateMetadata(props: {
23
+
params: Promise<{ publication: string; did: string }>;
24
}): Promise<Metadata> {
25
+
let did = decodeURIComponent((await props.params).did);
26
if (!did) return { title: "Publication 404" };
27
28
let { result: publication } = await get_publication_data.handler(
···
38
39
//This is the admin dashboard of the publication
40
export default async function Publication(props: {
41
+
params: Promise<{ publication: string; did: string }>;
42
}) {
43
let params = await props.params;
44
let identity = await getIdentityData();
45
+
if (!identity || !identity.atp_did) return <div>not logged in</div>;
46
+
let did = decodeURIComponent(params.did);
47
if (!did) return <PubNotFound />;
48
let { result: publication } = await get_publication_data.handler(
49
{
···
53
{ supabase: supabaseServerClient },
54
);
55
56
+
let record = publication?.record as PubLeafletPublication.Record | null;
57
if (!publication || identity.atp_did !== publication.identity_did)
58
return <PubNotFound />;
59
···
77
>
78
<PublicationDashboard
79
did={did}
80
+
icon={record?.icon ? record.icon : null}
81
name={publication.name}
82
tabs={{
83
Drafts: <DraftList />,
+10
-12
app/lish/[handle]/[publication]/page.tsx
app/lish/[did]/[publication]/page.tsx
+10
-12
app/lish/[handle]/[publication]/page.tsx
app/lish/[did]/[publication]/page.tsx
···
1
-
import { IdResolver } from "@atproto/identity";
2
import { supabaseServerClient } from "supabase/serverClient";
3
import { Metadata } from "next";
4
···
8
import { AtUri } from "@atproto/syntax";
9
import { PubLeafletDocument, PubLeafletPublication } from "lexicons/api";
10
import Link from "next/link";
11
-
12
-
const idResolver = new IdResolver();
13
14
export async function generateMetadata(props: {
15
-
params: Promise<{ publication: string; handle: string }>;
16
}): Promise<Metadata> {
17
-
let did = await idResolver.handle.resolve((await props.params).handle);
18
if (!did) return { title: "Publication 404" };
19
20
let { result: publication } = await get_publication_data.handler(
21
{
22
did,
23
-
publication_name: decodeURIComponent((await props.params).publication),
24
},
25
{ supabase: supabaseServerClient },
26
);
27
if (!publication) return { title: "404 Publication" };
28
-
return { title: decodeURIComponent((await props.params).publication) };
29
}
30
31
export default async function Publication(props: {
32
-
params: Promise<{ publication: string; handle: string }>;
33
}) {
34
let params = await props.params;
35
-
let did = await idResolver.handle.resolve((await props.params).handle);
36
if (!did) return <PubNotFound />;
37
let { data: publication } = await supabaseServerClient
38
.from("publications")
···
42
`,
43
)
44
.eq("identity_did", did)
45
-
.eq("name", decodeURIComponent((await props.params).publication))
46
.single();
47
48
let record = publication?.record as PubLeafletPublication.Record;
49
50
if (!publication) return <PubNotFound />;
51
-
console.log(record.icon);
52
try {
53
return (
54
<ThemeProvider entityID={null}>
···
93
<React.Fragment key={doc.documents?.uri}>
94
<div className="flex w-full ">
95
<Link
96
-
href={`/lish/${params.handle}/${params.publication}/${uri.rkey}`}
97
className="publishedPost grow flex flex-col hover:!no-underline"
98
>
99
<h3 className="text-primary">{record.title}</h3>
···
1
import { supabaseServerClient } from "supabase/serverClient";
2
import { Metadata } from "next";
3
···
7
import { AtUri } from "@atproto/syntax";
8
import { PubLeafletDocument, PubLeafletPublication } from "lexicons/api";
9
import Link from "next/link";
10
+
import { getPublicationURL } from "app/lish/createPub/getPublicationURL";
11
12
export async function generateMetadata(props: {
13
+
params: Promise<{ publication: string; did: string }>;
14
}): Promise<Metadata> {
15
+
let params = await props.params;
16
+
let did = decodeURIComponent(params.did);
17
if (!did) return { title: "Publication 404" };
18
19
let { result: publication } = await get_publication_data.handler(
20
{
21
did,
22
+
publication_name: decodeURIComponent(params.publication),
23
},
24
{ supabase: supabaseServerClient },
25
);
26
if (!publication) return { title: "404 Publication" };
27
+
return { title: decodeURIComponent(params.publication) };
28
}
29
30
export default async function Publication(props: {
31
+
params: Promise<{ publication: string; did: string }>;
32
}) {
33
let params = await props.params;
34
+
let did = decodeURIComponent(params.did);
35
if (!did) return <PubNotFound />;
36
let { data: publication } = await supabaseServerClient
37
.from("publications")
···
41
`,
42
)
43
.eq("identity_did", did)
44
+
.eq("name", decodeURIComponent(params.publication))
45
.single();
46
47
let record = publication?.record as PubLeafletPublication.Record;
48
49
if (!publication) return <PubNotFound />;
50
try {
51
return (
52
<ThemeProvider entityID={null}>
···
91
<React.Fragment key={doc.documents?.uri}>
92
<div className="flex w-full ">
93
<Link
94
+
href={`${getPublicationURL(publication)}/${uri.rkey}`}
95
className="publishedPost grow flex flex-col hover:!no-underline"
96
>
97
<h3 className="text-primary">{record.title}</h3>
+58
-23
app/lish/createPub/CreatePubForm.tsx
+58
-23
app/lish/createPub/CreatePubForm.tsx
···
8
import { useRouter } from "next/navigation";
9
import { useState, useRef, useEffect } from "react";
10
import { useDebouncedEffect } from "src/hooks/useDebouncedEffect";
11
-
import { set } from "colorjs.io/fn";
12
import { theme } from "tailwind.config";
13
14
export const CreatePubForm = () => {
15
let [nameValue, setNameValue] = useState("");
···
20
let fileInputRef = useRef<HTMLInputElement>(null);
21
22
let router = useRouter();
23
-
let { identity } = useIdentityData();
24
return (
25
<form
26
className="flex flex-col gap-3"
27
onSubmit={async (e) => {
28
e.preventDefault();
29
-
// Note: You'll need to update the createPublication function to handle the logo file
30
-
await createPublication({
31
name: nameValue,
32
description: descriptionValue,
33
iconFile: logoFile,
34
});
35
-
router.push(
36
-
`/lish/${identity?.resolved_did?.alsoKnownAs?.[0].slice(5)}/${nameValue}/dashboard`,
37
-
);
38
}}
39
>
40
<div className="flex flex-col items-center mb-4 gap-2">
···
103
);
104
};
105
106
function DomainInput(props: {
107
domain: string;
108
setDomain: (d: string) => void;
109
}) {
110
-
let [state, setState] = useState<"empty" | "valid" | "invalid" | "pending">(
111
-
"empty",
112
-
);
113
useEffect(() => {
114
if (!props.domain) {
115
-
setState("empty");
116
} else {
117
-
setState("pending");
118
}
119
}, [props.domain]);
120
useDebouncedEffect(
121
async () => {
122
-
if (!props.domain) return setState("empty");
123
let status = await callRPC("get_leaflet_subdomain_status", {
124
domain: props.domain,
125
});
126
console.log(status);
127
-
if (status.error === "Not Found") setState("valid");
128
-
else setState("invalid");
129
},
130
500,
131
[props.domain],
132
);
133
return (
134
<div className="flex flex-col gap-1">
135
<label className=" input-with-border flex flex-col text-sm text-tertiary font-bold italic leading-tight !py-1 !px-[6px]">
136
<div>Domain</div>
137
<div className="flex flex-row items-center">
138
<Input
139
placeholder="domain"
140
className="appearance-none w-full font-normal bg-transparent text-base text-primary focus:outline-0 outline-none"
141
value={props.domain}
···
147
<div
148
className={"text-sm italic "}
149
style={{
150
-
fontWeight: state === "valid" ? "bold" : "normal",
151
color:
152
-
state === "valid"
153
? theme.colors["accent-contrast"]
154
: theme.colors.tertiary,
155
}}
156
>
157
-
{state === "valid"
158
? "Available!"
159
-
: state === "invalid"
160
-
? "Already Taken ):"
161
-
: state === "pending"
162
-
? "Checking Availability..."
163
-
: "Choose a domain!"}
164
</div>
165
</div>
166
);
···
8
import { useRouter } from "next/navigation";
9
import { useState, useRef, useEffect } from "react";
10
import { useDebouncedEffect } from "src/hooks/useDebouncedEffect";
11
import { theme } from "tailwind.config";
12
+
import { getPublicationURL } from "./getPublicationURL";
13
+
import { string } from "zod";
14
15
export const CreatePubForm = () => {
16
let [nameValue, setNameValue] = useState("");
···
21
let fileInputRef = useRef<HTMLInputElement>(null);
22
23
let router = useRouter();
24
return (
25
<form
26
className="flex flex-col gap-3"
27
onSubmit={async (e) => {
28
e.preventDefault();
29
+
if (!subdomainValidator.safeParse(domainValue).success) return;
30
+
let data = await createPublication({
31
name: nameValue,
32
description: descriptionValue,
33
iconFile: logoFile,
34
+
subdomain: domainValue,
35
});
36
+
if (data?.publication)
37
+
router.push(`${getPublicationURL(data.publication)}/dashboard`);
38
}}
39
>
40
<div className="flex flex-col items-center mb-4 gap-2">
···
103
);
104
};
105
106
+
let subdomainValidator = string()
107
+
.min(3)
108
+
.max(63)
109
+
.regex(/^[a-z0-9-]+$/);
110
function DomainInput(props: {
111
domain: string;
112
setDomain: (d: string) => void;
113
}) {
114
+
type DomainState =
115
+
| { status: "empty" }
116
+
| { status: "valid" }
117
+
| { status: "invalid" }
118
+
| { status: "pending" }
119
+
| { status: "error"; message: string };
120
+
121
+
let [state, setState] = useState<DomainState>({ status: "empty" });
122
+
123
useEffect(() => {
124
if (!props.domain) {
125
+
setState({ status: "empty" });
126
} else {
127
+
let valid = subdomainValidator.safeParse(props.domain);
128
+
if (!valid.success) {
129
+
let reason = valid.error.errors[0].code;
130
+
setState({
131
+
status: "error",
132
+
message:
133
+
reason === "too_small"
134
+
? "Must be at least 3 characters long"
135
+
: reason === "invalid_string"
136
+
? "Must contain only lowercase letters, numbers, and dashes"
137
+
: "",
138
+
});
139
+
return;
140
+
}
141
+
setState({ status: "pending" });
142
}
143
}, [props.domain]);
144
+
145
useDebouncedEffect(
146
async () => {
147
+
if (!props.domain) return setState({ status: "empty" });
148
+
149
+
let valid = subdomainValidator.safeParse(props.domain);
150
+
if (!valid.success) {
151
+
return;
152
+
}
153
let status = await callRPC("get_leaflet_subdomain_status", {
154
domain: props.domain,
155
});
156
console.log(status);
157
+
if (status.error === "Not Found") setState({ status: "valid" });
158
+
else setState({ status: "invalid" });
159
},
160
500,
161
[props.domain],
162
);
163
+
164
return (
165
<div className="flex flex-col gap-1">
166
<label className=" input-with-border flex flex-col text-sm text-tertiary font-bold italic leading-tight !py-1 !px-[6px]">
167
<div>Domain</div>
168
<div className="flex flex-row items-center">
169
<Input
170
+
minLength={3}
171
+
maxLength={63}
172
placeholder="domain"
173
className="appearance-none w-full font-normal bg-transparent text-base text-primary focus:outline-0 outline-none"
174
value={props.domain}
···
180
<div
181
className={"text-sm italic "}
182
style={{
183
+
fontWeight: state.status === "valid" ? "bold" : "normal",
184
color:
185
+
state.status === "valid"
186
? theme.colors["accent-contrast"]
187
: theme.colors.tertiary,
188
}}
189
>
190
+
{state.status === "valid"
191
? "Available!"
192
+
: state.status === "error"
193
+
? state.message
194
+
: state.status === "invalid"
195
+
? "Already Taken ):"
196
+
: state.status === "pending"
197
+
? "Checking Availability..."
198
+
: "Choose a domain! Numbers, characters, and hyphens only!"}
199
</div>
200
</div>
201
);
+50
-7
app/lish/createPub/createPublication.ts
+50
-7
app/lish/createPub/createPublication.ts
···
6
import { supabaseServerClient } from "supabase/serverClient";
7
import { Un$Typed } from "@atproto/api";
8
import { Json } from "supabase/database.types";
9
10
export async function createPublication({
11
name,
12
description,
13
iconFile,
14
}: {
15
name: string;
16
description: string;
17
iconFile: File | null;
18
}) {
19
const oauthClient = await createOauthClient();
20
let identity = await getIdentityData();
21
if (!identity || !identity.atp_did) return;
22
let credentialSession = await oauthClient.restore(identity.atp_did);
23
let agent = new AtpBaseClient(
24
credentialSession.fetchHandler.bind(credentialSession),
25
);
26
let record: Un$Typed<PubLeafletPublication.Record> = {
27
name,
28
};
29
30
if (description) {
···
50
);
51
52
//optimistically write to our db!
53
-
await supabaseServerClient.from("publications").upsert({
54
-
uri: result.uri,
55
-
identity_did: credentialSession.did!,
56
-
name: record.name,
57
-
record: record as Json,
58
-
});
59
60
-
return { success: true, name };
61
}
···
6
import { supabaseServerClient } from "supabase/serverClient";
7
import { Un$Typed } from "@atproto/api";
8
import { Json } from "supabase/database.types";
9
+
import { Vercel } from "@vercel/sdk";
10
+
import { isProductionDomain } from "src/utils/isProductionDeployment";
11
+
import { string } from "zod";
12
13
+
const VERCEL_TOKEN = process.env.VERCEL_TOKEN;
14
+
const vercel = new Vercel({
15
+
bearerToken: VERCEL_TOKEN,
16
+
});
17
+
let subdomainValidator = string()
18
+
.min(3)
19
+
.max(63)
20
+
.regex(/^[a-z0-9-]+$/);
21
export async function createPublication({
22
name,
23
description,
24
iconFile,
25
+
subdomain,
26
}: {
27
name: string;
28
description: string;
29
iconFile: File | null;
30
+
subdomain: string;
31
}) {
32
+
let isSubdomainValid = subdomainValidator.safeParse(subdomain);
33
+
if (!isSubdomainValid.success) {
34
+
return { success: false };
35
+
}
36
const oauthClient = await createOauthClient();
37
let identity = await getIdentityData();
38
if (!identity || !identity.atp_did) return;
39
+
40
+
let domain = `${subdomain}.leaflet.pub`;
41
+
42
let credentialSession = await oauthClient.restore(identity.atp_did);
43
let agent = new AtpBaseClient(
44
credentialSession.fetchHandler.bind(credentialSession),
45
);
46
let record: Un$Typed<PubLeafletPublication.Record> = {
47
name,
48
+
base_path: domain,
49
};
50
51
if (description) {
···
71
);
72
73
//optimistically write to our db!
74
+
let { data: publication } = await supabaseServerClient
75
+
.from("publications")
76
+
.upsert({
77
+
uri: result.uri,
78
+
identity_did: credentialSession.did!,
79
+
name: record.name,
80
+
record: record as Json,
81
+
})
82
+
.select()
83
+
.single();
84
85
+
// Create the custom domain
86
+
if (isProductionDomain()) {
87
+
console.log("Creating domain! " + domain);
88
+
await vercel.projects.addProjectDomain({
89
+
idOrName: "prj_9jX4tmYCISnm176frFxk07fF74kG",
90
+
teamId: "team_42xaJiZMTw9Sr7i0DcLTae9d",
91
+
requestBody: {
92
+
name: domain + ".leaflet.pub",
93
+
},
94
+
});
95
+
}
96
+
await supabaseServerClient
97
+
.from("custom_domains")
98
+
.insert({ domain, identity: identity.id, confirmed: true });
99
+
await supabaseServerClient
100
+
.from("publication_domains")
101
+
.insert({ domain, publication: result.uri });
102
+
103
+
return { success: true, publication };
104
}
+17
app/lish/createPub/getPublicationURL.ts
+17
app/lish/createPub/getPublicationURL.ts
···
···
1
+
import { AtUri } from "@atproto/syntax";
2
+
import { PubLeafletPublication } from "lexicons/api";
3
+
import { isProductionDomain } from "src/utils/isProductionDeployment";
4
+
import { Json } from "supabase/database.types";
5
+
6
+
export function getPublicationURL(pub: {
7
+
uri: string;
8
+
name: string;
9
+
record: Json;
10
+
}) {
11
+
let record = pub.record as PubLeafletPublication.Record;
12
+
if (isProductionDomain() && record?.base_path) {
13
+
return new URL(record.base_path);
14
+
}
15
+
let aturi = new AtUri(pub.uri);
16
+
return `/lish/${aturi.host}/${record?.name || pub.name}`;
17
+
}
+11
-7
app/lish/createPub/page.tsx
+11
-7
app/lish/createPub/page.tsx
···
1
import { CreatePubForm } from "./CreatePubForm";
2
3
export default async function CreatePub() {
4
return (
5
-
<div className="createPubPage relative w-full h-screen flex items-stretch bg-bg-leaflet p-4">
6
-
<div className="createPubContent h-full flex items-center max-w-sm w-full mx-auto ">
7
-
<div className="createPubFormWrapper h-fit w-full flex flex-col gap-4">
8
-
<h2 className="text-center">Create Your Publication!</h2>
9
-
<div className="container w-full p-3">
10
-
<CreatePubForm />
11
</div>
12
</div>
13
</div>
14
-
</div>
15
);
16
}
···
1
+
import { ThemeProvider } from "components/ThemeManager/ThemeProvider";
2
import { CreatePubForm } from "./CreatePubForm";
3
4
export default async function CreatePub() {
5
return (
6
+
// Eventually this can pull from home theme?
7
+
<ThemeProvider entityID={null}>
8
+
<div className="createPubPage relative w-full h-screen flex items-stretch bg-bg-leaflet p-4">
9
+
<div className="createPubContent h-full flex items-center max-w-sm w-full mx-auto ">
10
+
<div className="createPubFormWrapper h-fit w-full flex flex-col gap-4">
11
+
<h2 className="text-center">Create Your Publication!</h2>
12
+
<div className="container w-full p-3">
13
+
<CreatePubForm />
14
+
</div>
15
</div>
16
</div>
17
</div>
18
+
</ThemeProvider>
19
);
20
}
+4
-3
components/Pages/PublicationMetadata.tsx
+4
-3
components/Pages/PublicationMetadata.tsx
···
11
import { AtUri } from "@atproto/syntax";
12
import { PubLeafletDocument } from "lexicons/api";
13
import { publications } from "drizzle/schema";
14
export const PublicationMetadata = ({
15
cardBorderHidden,
16
}: {
···
24
let [descriptionState, setDescriptionState] = useState(
25
pub?.description || "",
26
);
27
-
let record = pub.documents?.data as PubLeafletDocument.Record | null;
28
let publishedAt = record?.publishedAt;
29
30
useEffect(() => {
···
55
>
56
<div className="flex gap-2">
57
<Link
58
-
href={`/lish/${identity?.resolved_did?.alsoKnownAs?.[0].slice(5)}/${pub.publications.name}/dashboard`}
59
className="text-accent-contrast font-bold hover:no-underline"
60
>
61
{pub.publications?.name}
···
98
<Link
99
target="_blank"
100
className="text-sm"
101
-
href={`/lish/${identity?.resolved_did?.alsoKnownAs?.[0].slice(5)}/${pub.publications.name}/${new AtUri(pub.doc).rkey}`}
102
>
103
View Post
104
</Link>
···
11
import { AtUri } from "@atproto/syntax";
12
import { PubLeafletDocument } from "lexicons/api";
13
import { publications } from "drizzle/schema";
14
+
import { getPublicationURL } from "app/lish/createPub/getPublicationURL";
15
export const PublicationMetadata = ({
16
cardBorderHidden,
17
}: {
···
25
let [descriptionState, setDescriptionState] = useState(
26
pub?.description || "",
27
);
28
+
let record = pub?.documents?.data as PubLeafletDocument.Record | null;
29
let publishedAt = record?.publishedAt;
30
31
useEffect(() => {
···
56
>
57
<div className="flex gap-2">
58
<Link
59
+
href={`${getPublicationURL(pub.publications)}/dashboard`}
60
className="text-accent-contrast font-bold hover:no-underline"
61
>
62
{pub.publications?.name}
···
99
<Link
100
target="_blank"
101
className="text-sm"
102
+
href={`${getPublicationURL(pub.publications)}/${new AtUri(pub.doc).rkey}`}
103
>
104
View Post
105
</Link>
+19
-6
drizzle/relations.ts
+19
-6
drizzle/relations.ts
···
1
import { relations } from "drizzle-orm/relations";
2
-
import { entities, facts, entity_sets, permission_tokens, identities, email_subscriptions_to_entity, email_auth_tokens, phone_rsvps_to_entity, custom_domains, custom_domain_routes, poll_votes_on_entity, subscribers_to_publications, publications, permission_token_on_homepage, documents, documents_in_publications, leaflets_in_publications, permission_token_rights } from "./schema";
3
4
export const factsRelations = relations(facts, ({one}) => ({
5
entity: one(entities, {
···
107
fields: [custom_domains.identity],
108
references: [identities.email]
109
}),
110
}));
111
112
export const poll_votes_on_entityRelations = relations(poll_votes_on_entity, ({one}) => ({
···
122
}),
123
}));
124
125
-
export const subscribers_to_publicationsRelations = relations(subscribers_to_publications, ({one}) => ({
126
-
identity: one(identities, {
127
-
fields: [subscribers_to_publications.identity],
128
-
references: [identities.email]
129
}),
130
publication: one(publications, {
131
-
fields: [subscribers_to_publications.publication],
132
references: [publications.uri]
133
}),
134
}));
135
136
export const publicationsRelations = relations(publications, ({many}) => ({
137
subscribers_to_publications: many(subscribers_to_publications),
138
documents_in_publications: many(documents_in_publications),
139
leaflets_in_publications: many(leaflets_in_publications),
140
}));
141
142
export const permission_token_on_homepageRelations = relations(permission_token_on_homepage, ({one}) => ({
···
1
import { relations } from "drizzle-orm/relations";
2
+
import { entities, facts, entity_sets, permission_tokens, identities, email_subscriptions_to_entity, email_auth_tokens, phone_rsvps_to_entity, custom_domains, custom_domain_routes, poll_votes_on_entity, publication_domains, publications, subscribers_to_publications, permission_token_on_homepage, documents, documents_in_publications, leaflets_in_publications, permission_token_rights } from "./schema";
3
4
export const factsRelations = relations(facts, ({one}) => ({
5
entity: one(entities, {
···
107
fields: [custom_domains.identity],
108
references: [identities.email]
109
}),
110
+
publication_domains: many(publication_domains),
111
}));
112
113
export const poll_votes_on_entityRelations = relations(poll_votes_on_entity, ({one}) => ({
···
123
}),
124
}));
125
126
+
export const publication_domainsRelations = relations(publication_domains, ({one}) => ({
127
+
custom_domain: one(custom_domains, {
128
+
fields: [publication_domains.domain],
129
+
references: [custom_domains.domain]
130
}),
131
publication: one(publications, {
132
+
fields: [publication_domains.publication],
133
references: [publications.uri]
134
}),
135
}));
136
137
export const publicationsRelations = relations(publications, ({many}) => ({
138
+
publication_domains: many(publication_domains),
139
subscribers_to_publications: many(subscribers_to_publications),
140
documents_in_publications: many(documents_in_publications),
141
leaflets_in_publications: many(leaflets_in_publications),
142
+
}));
143
+
144
+
export const subscribers_to_publicationsRelations = relations(subscribers_to_publications, ({one}) => ({
145
+
identity: one(identities, {
146
+
fields: [subscribers_to_publications.identity],
147
+
references: [identities.email]
148
+
}),
149
+
publication: one(publications, {
150
+
fields: [subscribers_to_publications.publication],
151
+
references: [publications.uri]
152
+
}),
153
}));
154
155
export const permission_token_on_homepageRelations = relations(permission_token_on_homepage, ({one}) => ({
+11
drizzle/schema.ts
+11
drizzle/schema.ts
···
160
voter_token: uuid("voter_token").notNull(),
161
});
162
163
export const subscribers_to_publications = pgTable("subscribers_to_publications", {
164
identity: text("identity").notNull().references(() => identities.email, { onUpdate: "cascade" } ),
165
publication: text("publication").notNull().references(() => publications.uri),
···
160
voter_token: uuid("voter_token").notNull(),
161
});
162
163
+
export const publication_domains = pgTable("publication_domains", {
164
+
publication: text("publication").notNull().references(() => publications.uri, { onDelete: "cascade" } ),
165
+
domain: text("domain").notNull().references(() => custom_domains.domain, { onDelete: "cascade" } ),
166
+
created_at: timestamp("created_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
167
+
},
168
+
(table) => {
169
+
return {
170
+
publication_domains_pkey: primaryKey({ columns: [table.publication, table.domain], name: "publication_domains_pkey"}),
171
+
}
172
+
});
173
+
174
export const subscribers_to_publications = pgTable("subscribers_to_publications", {
175
identity: text("identity").notNull().references(() => identities.email, { onUpdate: "cascade" } ),
176
publication: text("publication").notNull().references(() => publications.uri),
+1
-1
middleware.ts
+1
-1
middleware.ts
+13
src/auth.ts
+13
src/auth.ts
···
···
1
+
import { cookies } from "next/headers";
2
+
import { isProductionDomain } from "./utils/isProductionDeployment";
3
+
4
+
export async function setAuthToken(tokenID: string) {
5
+
let c = await cookies();
6
+
c.set("auth_token", tokenID, {
7
+
maxAge: 60 * 60 * 24 * 365,
8
+
secure: process.env.NODE_ENV === "production",
9
+
domain: isProductionDomain() ? "leaflet.pub" : undefined,
10
+
httpOnly: true,
11
+
sameSite: "lax",
12
+
});
13
+
}
+7
src/utils/isProductionDeployment.ts
+7
src/utils/isProductionDeployment.ts
+33
supabase/database.types.ts
+33
supabase/database.types.ts
···
641
},
642
]
643
}
644
+
publication_domains: {
645
+
Row: {
646
+
created_at: string
647
+
domain: string
648
+
publication: string
649
+
}
650
+
Insert: {
651
+
created_at?: string
652
+
domain: string
653
+
publication: string
654
+
}
655
+
Update: {
656
+
created_at?: string
657
+
domain?: string
658
+
publication?: string
659
+
}
660
+
Relationships: [
661
+
{
662
+
foreignKeyName: "publication_domains_domain_fkey"
663
+
columns: ["domain"]
664
+
isOneToOne: false
665
+
referencedRelation: "custom_domains"
666
+
referencedColumns: ["domain"]
667
+
},
668
+
{
669
+
foreignKeyName: "publication_domains_publication_fkey"
670
+
columns: ["publication"]
671
+
isOneToOne: false
672
+
referencedRelation: "publications"
673
+
referencedColumns: ["uri"]
674
+
},
675
+
]
676
+
}
677
publications: {
678
Row: {
679
identity_did: string
+33
supabase/migrations/20250520190442_add_publication_domains_table.sql
+33
supabase/migrations/20250520190442_add_publication_domains_table.sql
···
···
1
+
create table "public"."publication_domains" (
2
+
"publication" text not null,
3
+
"domain" text not null,
4
+
"created_at" timestamp with time zone not null default now()
5
+
);
6
+
alter table "public"."publication_domains" enable row level security;
7
+
CREATE UNIQUE INDEX publication_domains_pkey ON public.publication_domains USING btree (publication, domain);
8
+
alter table "public"."publication_domains" add constraint "publication_domains_pkey" PRIMARY KEY using index "publication_domains_pkey";
9
+
alter table "public"."publication_domains" add constraint "publication_domains_domain_fkey" FOREIGN KEY (domain) REFERENCES custom_domains(domain) ON DELETE CASCADE not valid;
10
+
alter table "public"."publication_domains" validate constraint "publication_domains_domain_fkey";
11
+
alter table "public"."publication_domains" add constraint "publication_domains_publication_fkey" FOREIGN KEY (publication) REFERENCES publications(uri) ON DELETE CASCADE not valid;
12
+
alter table "public"."publication_domains" validate constraint "publication_domains_publication_fkey";
13
+
grant delete on table "public"."publication_domains" to "anon";
14
+
grant insert on table "public"."publication_domains" to "anon";
15
+
grant references on table "public"."publication_domains" to "anon";
16
+
grant select on table "public"."publication_domains" to "anon";
17
+
grant trigger on table "public"."publication_domains" to "anon";
18
+
grant truncate on table "public"."publication_domains" to "anon";
19
+
grant update on table "public"."publication_domains" to "anon";
20
+
grant delete on table "public"."publication_domains" to "authenticated";
21
+
grant insert on table "public"."publication_domains" to "authenticated";
22
+
grant references on table "public"."publication_domains" to "authenticated";
23
+
grant select on table "public"."publication_domains" to "authenticated";
24
+
grant trigger on table "public"."publication_domains" to "authenticated";
25
+
grant truncate on table "public"."publication_domains" to "authenticated";
26
+
grant update on table "public"."publication_domains" to "authenticated";
27
+
grant delete on table "public"."publication_domains" to "service_role";
28
+
grant insert on table "public"."publication_domains" to "service_role";
29
+
grant references on table "public"."publication_domains" to "service_role";
30
+
grant select on table "public"."publication_domains" to "service_role";
31
+
grant trigger on table "public"."publication_domains" to "service_role";
32
+
grant truncate on table "public"."publication_domains" to "service_role";
33
+
grant update on table "public"."publication_domains" to "service_role";