Unify datetime handling for blog

Author: michaelfortunato

lib/buildInfo.ts

@@ -14,7 +14,7 @@ export type CommitEntry = {
   commitHash: string;
   readonly shortCommitHash: string;
   author: string;
-  timestamp: string;
+  timestamp: Date;
   message: string;
 };
 

lib/posts.ts

@@ -1,52 +1,115 @@
 import { CommitEntry } from "@/lib/buildInfo";
+import {
+  fromISODateString,
+  Serialized,
+  toISODateString,
+} from "@/lib/utils";
 
 type MetadataArgs = {
   id: string;
   title: string;
-  tags?: string[];
+  tags: string[];
   buildInfo: {
     isDirty: boolean;
     currentCommit: CommitEntry;
     firstCommit: CommitEntry;
   };
-  version?: number;
-  createdTimestamp?: string;
-  modifiedTimestamp?: string;
+  createdTimestamp: Date | null;
+  modifiedTimestamp: Date | null;
 };
 
-export class Metadata {
+export class PostMetadata {
   id: string;
   title: string;
   tags: string[];
-  createdTimestamp: string;
-  modifiedTimestamp: string;
+  createdTimestamp: Date;
+  modifiedTimestamp: Date;
   buildInfo: MetadataArgs["buildInfo"];
-  version?: number;
 
   constructor({
     id,
     title,
     tags = [],
     buildInfo,
-    version,
     createdTimestamp,
     modifiedTimestamp,
   }: MetadataArgs) {
     this.id = id;
     this.title = title;
     this.tags = tags;
     this.buildInfo = buildInfo;
-    this.version = version;
     this.createdTimestamp =
       createdTimestamp ?? this.buildInfo.firstCommit.timestamp;
     this.modifiedTimestamp =
       modifiedTimestamp ?? this.buildInfo.currentCommit.timestamp;
   }
 }
+
 export type Post = {
-  metadata: Metadata;
+  metadata: PostMetadata;
   content: {
     head: string;
     body: string;
   }; // Rendered file contents, most likely as rendered html
 };
+
+export type SerializedPostMetadata = Serialized<PostMetadata>;
+export type SerializedPost = Serialized<Post>;
+
+function serializeCommitEntry(entry: CommitEntry): Serialized<CommitEntry> {
+  return {
+    ...entry,
+    timestamp: toISODateString(entry.timestamp),
+  };
+}
+
+function deserializeCommitEntry(entry: Serialized<CommitEntry>): CommitEntry {
+  return {
+    ...entry,
+    timestamp: fromISODateString(entry.timestamp),
+  };
+}
+
+export function serializePostMetadata(
+  metadata: PostMetadata,
+): SerializedPostMetadata {
+  return {
+    ...metadata,
+    createdTimestamp: toISODateString(metadata.createdTimestamp),
+    modifiedTimestamp: toISODateString(metadata.modifiedTimestamp),
+    buildInfo: {
+      ...metadata.buildInfo,
+      currentCommit: serializeCommitEntry(metadata.buildInfo.currentCommit),
+      firstCommit: serializeCommitEntry(metadata.buildInfo.firstCommit),
+    },
+  };
+}
+
+export function deserializePostMetadata(
+  metadata: SerializedPostMetadata,
+): PostMetadata {
+  return new PostMetadata({
+    ...metadata,
+    createdTimestamp: fromISODateString(metadata.createdTimestamp),
+    modifiedTimestamp: fromISODateString(metadata.modifiedTimestamp),
+    buildInfo: {
+      ...metadata.buildInfo,
+      currentCommit: deserializeCommitEntry(metadata.buildInfo.currentCommit),
+      firstCommit: deserializeCommitEntry(metadata.buildInfo.firstCommit),
+    },
+  });
+}
+
+export function serializePost(post: Post): SerializedPost {
+  return {
+    ...post,
+    metadata: serializePostMetadata(post.metadata),
+  };
+}
+
+export function deserializePost(post: SerializedPost): Post {
+  return {
+    ...post,
+    metadata: deserializePostMetadata(post.metadata),
+  };
+}

lib/server-only/buildInfo.ts

@@ -20,16 +20,21 @@ export async function getBuildInfo(): Promise<BuildInfo> {
 }
 
 export function getCommitEntryForFile(filepath: string, head: boolean = true) {
-  const commitEntryPattern = /^([a-f0-9]+) - ([^,]+), ([^:]+) : (.+)$/;
+  // Prior style for reference: "%H - %an, %at : %s"
+  // Example: "8fd2212f... - Michael Fortunato, 1739958235 : tighten static props typing"
+  const commitEntryFormat = "%H%x1f%an%x1f%aI%x1f%s";
   const cmd = !head
-    ? `git log --reverse --pretty=format:"%H - %an, %at : %s" -- ${filepath} | head -1`
-    : `git log -1 --pretty=format:"%H - %an, %at : %s" -- ${filepath}`;
+    ? `git log --reverse --pretty=format:"${commitEntryFormat}" -- ${filepath} | head -1`
+    : `git log -1 --pretty=format:"${commitEntryFormat}" -- ${filepath}`;
   const commitEntry = launchShellCmd(cmd)?.toString().trim();
-  if (commitEntry == undefined) return undefined;
-  const [, commitHash, author, timestamp, message] =
-    commitEntry.match(commitEntryPattern) || [];
-  if (!(commitHash && author && timestamp && message)) {
-    return undefined;
+  if (commitEntry == null) return null;
+  const [commitHash, author, authorDateISO, message] = commitEntry.split("\x1f");
+  if (!(commitHash && author && authorDateISO && message)) {
+    return null;
+  }
+  const timestamp = new Date(authorDateISO);
+  if (Number.isNaN(timestamp.valueOf())) {
+    return null;
   }
   return {
     commitHash,

lib/server-only/posts.ts

@@ -10,7 +10,8 @@ import {
   getGitDir,
   isDirty as isDirtyFunc,
 } from "./buildInfo";
-import { Metadata, Post } from "@/lib/posts";
+import { PostMetadata, Post } from "@/lib/posts";
+import { parseTimestamp, unwrap } from "@/lib/utils"
 
 export function getCommitInfoForFileOrFallback(filepath: string) {
   const firstCommit = getCommitEntryForFile(filepath, false);
@@ -20,14 +21,14 @@ export function getCommitInfoForFileOrFallback(filepath: string) {
     return { isDirty, firstCommit, currentCommit };
   }
 
-  const nowSeconds = Math.floor(Date.now() / 1000).toString();
+  const now = new Date()
   const fallbackCommit = {
     commitHash: "UNCOMMITTED",
     get shortCommitHash() {
       return this.commitHash.slice(0, 7);
     },
     author: "Michael Fortunato (unverified)",
-    timestamp: nowSeconds,
+    timestamp: now,
     message: "Uncommited/non-existant file",
   };
 
@@ -46,11 +47,34 @@ function isRecord(v: unknown): v is Record<string, unknown> {
   return typeof v === "object" && v !== null;
 }
 
-function asString(v: unknown): string | undefined {
+function asString(v: unknown): string | null {
   if (typeof v === "string") return v;
   if (isRecord(v) && typeof v.value === "string") return v.value;
   if (isRecord(v) && typeof v.text === "string") return v.text;
-  return undefined;
+  return null;
+}
+
+function asNumber(v: unknown):  number | null {
+  if (typeof v === "number") return Number(v);
+  return null;
+}
+
+function asBoolean(v: unknown): boolean | null {
+  if (typeof v === "boolean") return v;
+  // There must be a better way than this...
+  const vs = asString(v)
+  if (vs === null) {
+    return null
+  }
+  const t = vs.trim().toLowerCase();
+  if (t === "true") return true;
+  if (t === "false") return false;
+  return null;
+}
+
+function asTimestamp(v: unknown): Date | null {
+  const ms_since_unix_epoch = asNumber(v)
+  return parseTimestamp(ms_since_unix_epoch)
 }
 
 function asStringArray(v: unknown): string[] {
@@ -89,7 +113,10 @@ function findLabelValue(items: unknown[], ...labels: string[]): unknown {
 // --- typst query + parse ---
 export async function _typstQuery(typstFilepath: string): Promise<unknown[]> {
   const TYPST_QUERY =
-    "selector(<KEYWORDS>).or(<keywords>).or(<tags>).or(<TITLE>).or(<title>)";
+    "selector(<KEYWORDS>).or(<keywords>)"
+    + ".or(<tags>)"
+    + ".or(<TITLE>).or(<title>)"
+    + ".or(<CREATED_TIMESTAMP>).or(<MODIFIED_TIMESTAMP>)";
   const root = await getGitDir();
   const { stdout } = await execFileAsync("typst", [
     "query",
@@ -154,6 +181,8 @@ export async function _typstFileToMetadata(typstFilepath: string) {
     id: (await idFromPostPath(typstFilepath)) || "<UNKNOWN ID>",
     title: asString(findLabelValue(items, "TITLE")) || "<UNKNOWN TITLE>",
     tags: asStringArray(findLabelValue(items, "KEYWORDS", "TAGS")),
+    createdTimestamp: asTimestamp(findLabelValue(items, "CREATED_TIMESTAMP")),
+    modifiedTimestamp: asTimestamp(findLabelValue(items, "MODIFIED_TIMESTAMP")),
   };
 }
 function splitHeadBody(html: string) {
@@ -207,15 +236,17 @@ export async function listPostIds(): Promise<string[]> {
   return Promise.all(files.map((file) => idFromPostPath(file)));
 }
 
-export async function listPosts(): Promise<Metadata[]> {
+export async function listPosts(): Promise<PostMetadata[]> {
   const postFiles = await listPostFiles();
   const postsWithMetadata = await Promise.all(
     postFiles.map(async (postFile) => {
-      const { id, title, tags } = await _typstFileToMetadata(postFile);
+      const { id, title, tags, createdTimestamp, modifiedTimestamp } = await _typstFileToMetadata(postFile);
       const buildInfo = getCommitInfoForFileOrFallback(postFile);
-      return new Metadata({
+      return new PostMetadata({
         id,
         title,
+        createdTimestamp,
+        modifiedTimestamp,
         tags,
         buildInfo,
       });
@@ -227,9 +258,9 @@ export async function listPosts(): Promise<Metadata[]> {
 export async function buildPost(inputFilepath: string): Promise<Post> {
   const htmlString = await _typstFileToHTMLFile(inputFilepath);
   const headAndBody = splitHeadBody(htmlString);
-  const { id, title, tags } = await _typstFileToMetadata(inputFilepath);
+  const { id, title, tags, createdTimestamp, modifiedTimestamp } = await _typstFileToMetadata(inputFilepath);
   const buildInfo = getCommitInfoForFileOrFallback(inputFilepath);
-  const metadata = new Metadata({ id, title, tags, buildInfo });
+  const metadata = new PostMetadata({ id, title, createdTimestamp, modifiedTimestamp, tags, buildInfo });
   return {
     content: headAndBody,
     metadata,

lib/utils.ts

@@ -4,3 +4,86 @@ import { twMerge } from "tailwind-merge";
 export function cn(...inputs: ClassValue[]) {
   return twMerge(clsx(inputs));
 }
+
+export type ISODateString = string & { readonly __isoDateStringBrand: true };
+
+type Primitive = string | number | boolean | null | undefined;
+
+export type Serialized<T> = T extends Date
+  ? ISODateString
+  : T extends Primitive
+    ? T
+    : T extends readonly (infer U)[]
+      ? Serialized<U>[]
+      : T extends object
+        ? { [K in keyof T]: Serialized<T[K]> }
+        : never;
+
+export function toISODateString(value: Date): ISODateString {
+  return value.toISOString() as ISODateString;
+}
+
+export function fromISODateString(value: ISODateString | string): Date {
+  return new Date(value);
+}
+
+// AI Slop
+export type Option<T> = T | null;
+export const None: null = null;
+export const Some = <T>(x: T): Option<T> => x;
+
+export const isSome = <T>(o: Option<T>): o is T => o !== null;
+export const map = <T, U>(o: Option<T>, f: (x: T) => U): Option<U> =>
+  o === null ? null : f(o);
+export const andThen = <T, U>(o: Option<T>, f: (x: T) => Option<U>): Option<U> =>
+  o === null ? null : f(o);
+export const unwrapOr = <T>(o: Option<T>, d: T): T => (o === null ? d : o);
+export const unwrap = <T>(o: Option<T>): T => {
+  if (o === null) 
+    throw "Error"
+  return o;
+}
+
+
+/**
+ * NOTE: This was AI Generated.
+ *
+ * WARN: If you give a string that looks like a number 
+ * (specifically the numbers of ms since unix birth), we will not parse it.
+ *
+ * Parses a timestamp-like input into a valid `Date`.
+ *
+ * Happy-path inputs:
+ * - `Date`: returned directly if valid.
+ * - `number`: treated as Unix epoch milliseconds (same semantics as
+`new Date(ms)`).
+ * - `string`: must be parseable by the JS `Date` constructor; prefer
+ISO-8601
+ *   (e.g. `"2026-02-19T18:45:00.000Z"`).
+ *
+ * Notes:
+ * - Unix epoch seconds are not accepted directly; convert first with
+`seconds * 1000`.
+ * - Returns `null` for `null`, unsupported types, or invalid/
+unparseable date values.
+*/
+export function parseTimestamp(timestamp: unknown): Date | null {
+
+  if (timestamp === null || (!(timestamp instanceof Date)) && typeof timestamp !== "number" && typeof timestamp !== "string") {
+    return null
+  }
+  const date = timestamp instanceof Date ? timestamp : new Date(timestamp);
+  return Number.isNaN(date.valueOf()) ? null : date;
+}
+
+
+function happenedSameYear(ts1: Date, ts2: Date): boolean {
+  return ts1.getFullYear() == ts2.getFullYear()
+}
+
+function happenedSameMonth(ts1: Date, ts2: Date): boolean {
+  return happenedSameYear(ts1, ts2) && (ts1.getMonth() == ts2.getMonth())
+}
+export function happenedSameDay(ts1: Date, ts2: Date): boolean {
+  return happenedSameMonth(ts1, ts2) && (ts1.getDate() == ts2.getDate())
+}