Merge pull request #22 from unisoncomputing/social-image-definition

wip

Author: hojberg

deno.lock

@@ -0,0 +1,37 @@
+type SyntaxSegment = { annotation?: { tag: string }; segment: string };
+type DocElement = { annotation?: { tag: string }; segment: string };
+
+type DefinitionSyntax = {
+  contents: Array<SyntaxSegment>;
+  tag: "UserObject" | "BuiltinObject";
+};
+
+type APITerm = {
+  bestTermName: string;
+  defnTermTag: string;
+  signature: Array<SyntaxSegment>;
+  termDefinition: DefinitionSyntax;
+  termDocs: Array<DocElement>;
+};
+
+type APIType = {
+  bestTypeName: string;
+  defnTypeTag: string;
+  typeDefinition: DefinitionSyntax;
+  typeDocs: Array<DocElement>;
+};
+
+type APIDefinitions = {
+  missingDefinitions: Array<string>;
+  termDefinitions: Array<{ [key: string]: APITerm }>;
+  typeDefinitions: Array<{ [key: string]: APIType }>;
+};
+
+export {
+  SyntaxSegment,
+  DefinitionSyntax,
+  APITerm,
+  APIType,
+  APIDefinitions,
+  DocElement,
+};

netlify/edge-functions/common/definition.ts

@@ -1,3 +1,5 @@
+import { APIDefinition } from "./definition.ts";
+
 type APIProject = {
   owner: { handle: string };
   slug: string;
@@ -55,6 +57,12 @@ function apiHandle(handle: string): string {
 const ShareAPI = {
   baseURL: "https://api.unison-lang.org",
 
+  projectBaseUrl: (handle: string, projectSlug: string, path?: string) => {
+    return `${ShareAPI.baseURL}/users/${apiHandle(
+      handle
+    )}/projects/${projectSlug}${path || ""}`;
+  },
+
   getUser: async (handle: string): Promise<APIUser> => {
     return fetch(`${ShareAPI.baseURL}/users/${apiHandle(handle)}`).then(
       (resp) => {
@@ -71,9 +79,7 @@ const ShareAPI = {
     handle: string,
     projectSlug: string
   ): Promise<APIProject> => {
-    return fetch(
-      `${ShareAPI.baseURL}/users/${apiHandle(handle)}/projects/${projectSlug}`
-    ).then((resp) => {
+    return fetch(ShareAPI.projectBaseUrl(handle, projectSlug)).then((resp) => {
       if (!resp.ok) {
         throw new Error(resp.statusText);
       }
@@ -88,9 +94,11 @@ const ShareAPI = {
     contribRef: number
   ): Promise<APIContribution> => {
     return fetch(
-      `${ShareAPI.baseURL}/users/${apiHandle(
-        handle
-      )}/projects/${projectSlug}/contributions/${contribRef}`
+      ShareAPI.projectBaseUrl(
+        handle,
+        projectSlug,
+        `/contributions/${contribRef}`
+      )
     ).then((resp) => {
       if (!resp.ok) {
         throw new Error(resp.statusText);
@@ -106,9 +114,7 @@ const ShareAPI = {
     ticketRef: number
   ): Promise<APITicket> => {
     return fetch(
-      `${ShareAPI.baseURL}/users/${apiHandle(
-        handle
-      )}/projects/${projectSlug}/tickets/${ticketRef}`
+      ShareAPI.projectBaseUrl(handle, projectSlug, `/tickets/${ticketRef}`)
     ).then((resp) => {
       if (!resp.ok) {
         throw new Error(resp.statusText);
@@ -124,9 +130,7 @@ const ShareAPI = {
     version: string
   ): Promise<APIRelease> => {
     return fetch(
-      `${ShareAPI.baseURL}/users/${apiHandle(
-        handle
-      )}/projects/${projectSlug}/releases/${version}`
+      ShareAPI.projectBaseUrl(handle, projectSlug, `/releases/${version}`)
     ).then((resp) => {
       if (!resp.ok) {
         throw new Error(resp.statusText);
@@ -135,11 +139,35 @@ const ShareAPI = {
       return resp.json() as Promise<APIRelease>;
     });
   },
+
   getDefinition: async (
-    _handle: string,
-    _projectSlug: string,
-    _fqn: Array<string>
-  ) => {},
+    handle: string,
+    projectSlug: string,
+    branchRef: string,
+    fqn: Array<string>
+  ): Promise<APIDefinitions> => {
+    function mkUrl(branchPart: string): string {
+      return ShareAPI.projectBaseUrl(
+        handle,
+        projectSlug,
+        `/${branchPart}/definitions/by-name/${fqn.join(".")}`
+      );
+    }
+
+    let url = mkUrl(`branches/${branchRef.replace("/", "%2F")}`);
+    if (branchRef.startsWith("releases")) {
+      url = mkUrl(branchRef);
+    }
+
+    return fetch(url).then((resp) => {
+      if (!resp.ok) {
+        throw new Error(resp.statusText);
+      }
+
+      return resp.json() as Promise<APIDefinitions>;
+    });
+  },
 };
 
 export default ShareAPI;
+export { ShareAPI };

netlify/edge-functions/common/share-api.ts

@@ -4,6 +4,7 @@ class Route extends SumType<{
   UserOverview: [string];
   ProjectOverview: [string, string];
   ProjectCode: [string, string, string | undefined];
+  ProjectDefinition: [string, string, string, string, Array<string>];
   ProjectTickets: [string, string];
   ProjectTicket: [string, string, number];
   ProjectContributions: [string, string];
@@ -30,6 +31,23 @@ function ProjectCode(
   return new Route("ProjectCode", handle, projectSlug, branchRef);
 }
 
+function ProjectDefinition(
+  handle: string,
+  projectSlug: string,
+  branchRef: string,
+  definitionType: string,
+  fqn: Array<string>
+): Route {
+  return new Route(
+    "ProjectDefinition",
+    handle,
+    projectSlug,
+    branchRef,
+    definitionType,
+    fqn
+  );
+}
+
 function ProjectTickets(handle: string, projectSlug: string): Route {
   return new Route("ProjectTickets", handle, projectSlug);
 }
@@ -79,11 +97,13 @@ function parse(rawUrl: string): Route {
   return fromPathname(url.pathname);
 }
 
+function isContributorBranchOrRelease(s: string): boolean {
+  return s.startsWith("@") || s.startsWith("releases");
+}
+
 function fromPathname(rawPath: string): Route {
   const parts = rawPath.split("/").filter((s) => s.length);
 
-  console.log("route parts", parts);
-
   const [handle, projectSlug, ...rest] = parts;
 
   if (handle && handle.startsWith("@") && !projectSlug) {
@@ -92,17 +112,41 @@ function fromPathname(rawPath: string): Route {
     const [projectPage] = rest;
 
     if (projectPage === "code") {
-      const [_, branchPart1, branchPart2] = rest;
+      const [
+        _,
+        branchPart1,
+        branchPart2,
+        namespaceHashOrDefinitionType,
+        definitionTypeOrNameSegment,
+        ...nameSegments
+      ] = rest;
 
       let branchRef = branchPart1;
-      if (
-        branchPart1 &&
-        (branchPart1.startsWith("@") || branchPart1.startsWith("releases"))
-      ) {
+      let fqn = nameSegments || [];
+      let definitionType = definitionTypeOrNameSegment;
+      if (branchPart1 && isContributorBranchOrRelease(branchPart1)) {
         branchRef = `${branchRef}/${branchPart2}`;
+      } else if (branchPart2) {
+        // if the branchPart1 contributor branch a release, then branch2 is a namespaceHash,
+        // which means the namespaceHashOrDefinitionType is a definition type, and definitionTypeOrNameSegment
+        // is the first part of the FQN
+        fqn = [definitionTypeOrNameSegment, ...nameSegments];
+        definitionType = namespaceHashOrDefinitionType;
       }
 
-      return ProjectCode(handle, projectSlug, branchRef);
+      // Gotta have an FQN to be a definition Route
+      if (fqn.length && definitionType) {
+        return ProjectDefinition(
+          handle,
+          projectSlug,
+          branchRef,
+          // remove the trailing 's' from the definition type
+          definitionType.substring(0, definitionType.length - 1),
+          fqn
+        );
+      } else {
+        return ProjectCode(handle, projectSlug, branchRef);
+      }
     } else if (projectPage === "tickets") {
       const [_, ticketRef] = rest;
 
@@ -141,6 +185,7 @@ export {
   UserOverview,
   ProjectOverview,
   ProjectCode,
+  ProjectDefinition,
   ProjectContributions,
   ProjectContribution,
   ProjectTickets,

netlify/edge-functions/common/share-route.ts

@@ -29,7 +29,12 @@ function userHandle(handle?: string): string {
 }
 
 function hash(h: string): string {
-  return h.replace("#", "").slice(0, 8);
+  // builtins starts with 2 ## and we shouldn't shorten them
+  if (h.startsWith("##")) {
+    return h.replaceAll("#", "");
+  } else {
+    return h.replaceAll("#", "").slice(0, 8);
+  }
 }
 
 export { truncate, titleize, intersperse, userHandle, hash };

netlify/edge-functions/common/utils.ts

@@ -73,6 +73,49 @@ async function getContent(rawUrl: string): Promise<SocialContent> {
       };
     },
 
+    async ProjectDefinition(
+      handle,
+      projectSlug,
+      branchRef,
+      definitionType,
+      ref
+    ) {
+      const project = await ShareAPI.getProject(handle, projectSlug);
+      const definitions = await ShareAPI.getDefinition(
+        handle,
+        projectSlug,
+        branchRef,
+        ref
+      );
+
+      if (!project) return DefaultSocialContent;
+      if (!definitions) return DefaultSocialContent;
+
+      let definition = null;
+      if (definitionType === "term") {
+        const [hash] = Object.keys(definitions.termDefinitions);
+        const raw = definitions.termDefinitions[hash];
+        if (hash) {
+          definition = { name: raw.bestTermName };
+        }
+      } else {
+        const [hash] = Object.keys(definitions.typeDefinitions);
+        const raw = definitions.typeDefinitions[hash];
+        if (hash) {
+          definition = { name: raw.bestTypeName };
+        }
+      }
+
+      if (!definition) return DefaultSocialContent;
+      const title = definition.name;
+
+      return {
+        title: `${title} · ${handle}/${projectSlug}/${branchRef} | Unison Share`,
+        description: project.summary,
+        imageUrl,
+      };
+    },
+
     async ProjectTickets(handle, projectSlug) {
       const project = await ShareAPI.getProject(handle, projectSlug);