@tscircuit/cli 0.0.62 → 0.0.63

package/cli.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 
+import kleur from "kleur"
 import { AppContext } from "./lib/util/app-context"
 import { createContextAndRunProgram } from "./lib/util/create-context-and-run-program"
 
@@ -7,6 +8,7 @@ async function main() {
   await createContextAndRunProgram(process.argv)
 }
 
-main().catch((e) => {
-  console.log("Error running CLI:", e.toString())
+main().catch((e: any) => {
+  console.log(kleur.gray(e.stack))
+  console.log(kleur.red(`Error running CLI: ${e.toString()}`))
 })

package/dev-server-api/routes/api/export_files/create.ts

@@ -0,0 +1,32 @@
+import { publicMapExportFile } from "src/lib/public-mapping/public-map-export-file"
+import { export_file } from "src/lib/zod/export_file"
+import { withEdgeSpec } from "src/with-edge-spec"
+import { z } from "zod"
+
+export default withEdgeSpec({
+  methods: ["POST"],
+  jsonBody: z.object({
+    export_request_id: z.number().int(),
+    file_name: z.string(),
+    file_content_base64: z.string().transform((a) => Buffer.from(a, "base64")),
+  }),
+  jsonResponse: z.object({
+    export_file,
+  }),
+  auth: "none",
+})(async (req, ctx) => {
+  const db_export_file = await ctx.db
+    .insertInto("export_file")
+    .values({
+      export_request_id: req.jsonBody.export_request_id,
+      file_name: req.jsonBody.file_name,
+      file_content: req.jsonBody.file_content_base64,
+      created_at: new Date().toISOString(),
+    })
+    .returningAll()
+    .executeTakeFirstOrThrow()
+
+  return ctx.json({
+    export_file: publicMapExportFile(db_export_file),
+  })
+})

package/dev-server-api/routes/api/export_files/download.ts

@@ -0,0 +1,24 @@
+import { publicMapExportFile } from "src/lib/public-mapping/public-map-export-file"
+import { export_file } from "src/lib/zod/export_file"
+import { withEdgeSpec } from "src/with-edge-spec"
+import { z } from "zod"
+
+export default withEdgeSpec({
+  methods: ["GET"],
+  queryParams: z.object({
+    export_file_id: z.coerce.number().int(),
+  }),
+  auth: "none",
+})(async (req, ctx) => {
+  const db_export_file = await ctx.db
+    .selectFrom("export_file")
+    .selectAll()
+    .where("export_file_id", "=", req.query.export_file_id)
+    .executeTakeFirstOrThrow()
+
+  return new Response(db_export_file.file_content, {
+    headers: {
+      "Content-Disposition": `attachment; filename="${db_export_file.file_name}"`,
+    },
+  })
+})

package/dev-server-api/routes/api/export_requests/create.ts

@@ -3,20 +3,14 @@ import { NotFoundError } from "edgespec/middleware"
 import { z } from "zod"
 import { export_request } from "src/lib/zod/export_request"
 import { publicMapExportRequest } from "src/lib/public-mapping/public-map-export-request"
+import { export_parameters } from "../../../src/lib/zod/export_parameters"
 
 export default withEdgeSpec({
   methods: ["POST"],
   jsonBody: z.object({
     example_file_path: z.string(),
     export_name: z.string().nullable().optional(),
-    export_parameters: z.object({
-      should_export_gerber_zip: z.boolean().default(false),
-      gerbers_zip_file_name: z
-        .string()
-        .nullable()
-        .optional()
-        .default("gerbers.zip"),
-    }),
+    export_parameters: export_parameters,
   }),
   jsonResponse: z.object({
     export_request,

package/dev-server-api/routes/api/export_requests/get.ts

@@ -0,0 +1,37 @@
+import { withEdgeSpec } from "src/with-edge-spec"
+import { z } from "zod"
+import { export_request } from "src/lib/zod/export_request"
+import { publicMapExportRequest } from "src/lib/public-mapping/public-map-export-request"
+
+export default withEdgeSpec({
+  methods: ["GET", "POST"],
+  commonParams: z.object({
+    export_request_id: z.coerce.number(),
+  }),
+  jsonResponse: z.object({
+    export_request: export_request,
+  }),
+  auth: "none",
+})(async (req, ctx) => {
+  const { export_request_id } = req.commonParams
+  const db_export_request: any = await ctx.db
+    .selectFrom("export_request")
+    .selectAll()
+    .where("export_request_id", "=", export_request_id)
+    .executeTakeFirstOrThrow()
+
+  db_export_request.file_summary = (
+    await ctx.db
+      .selectFrom("export_file")
+      .where("export_request_id", "=", export_request_id)
+      .selectAll()
+      .execute()
+  ).map((ef) => ({
+    file_name: ef.file_name,
+    export_file_id: ef.export_file_id,
+  }))
+
+  return ctx.json({
+    export_request: publicMapExportRequest(db_export_request),
+  })
+})

package/dev-server-api/routes/api/export_requests/list.ts

@@ -0,0 +1,28 @@
+import { withEdgeSpec } from "src/with-edge-spec"
+import { z } from "zod"
+import { export_request } from "src/lib/zod/export_request"
+import { publicMapExportRequest } from "src/lib/public-mapping/public-map-export-request"
+
+export default withEdgeSpec({
+  methods: ["GET", "POST"],
+  commonParams: z.object({
+    is_complete: z.boolean().nullable().default(null),
+  }),
+  jsonResponse: z.object({
+    export_requests: z.array(export_request),
+  }),
+  auth: "none",
+})(async (req, ctx) => {
+  const { is_complete } = req.commonParams
+  const db_export_requests = await ctx.db
+    .selectFrom("export_request")
+    .selectAll()
+    .$if(is_complete !== null, (q) =>
+      q.where("export_request.is_complete", "=", is_complete ? 1 : 0)
+    )
+    .execute()
+
+  return ctx.json({
+    export_requests: db_export_requests.map((er) => publicMapExportRequest(er)),
+  })
+})

package/dev-server-api/routes/api/export_requests/update.ts

@@ -0,0 +1,26 @@
+import { withEdgeSpec } from "src/with-edge-spec"
+import { NotFoundError } from "edgespec/middleware"
+import { z } from "zod"
+import { export_request } from "src/lib/zod/export_request"
+import { publicMapExportRequest } from "src/lib/public-mapping/public-map-export-request"
+import { export_parameters } from "src/lib/zod/export_parameters"
+
+export default withEdgeSpec({
+  methods: ["POST"],
+  jsonBody: z.object({
+    export_request_id: z.coerce.number(),
+    is_complete: z.boolean(),
+  }),
+  jsonResponse: z.object({}),
+  auth: "none",
+})(async (req, ctx) => {
+  await ctx.db
+    .updateTable("export_request")
+    .set({
+      is_complete: req.jsonBody.is_complete ? 1 : 0,
+    })
+    .where("export_request_id", "=", req.jsonBody.export_request_id)
+    .execute()
+
+  return ctx.json({})
+})

package/dev-server-api/src/db/get-db.ts

@@ -26,7 +26,6 @@ export interface ExportFile {
   export_file_id: Generated<number>
   file_name: string
   file_content: Buffer
-  is_complete: 1 | 0
   export_request_id: number
   created_at: string
 }

package/dev-server-api/src/lib/public-mapping/public-map-export-file.ts

@@ -0,0 +1,17 @@
+import type { ExportRequest } from "src/db/get-db"
+import { export_file } from "src/lib/zod/export_file"
+import { z } from "zod"
+
+export const publicMapExportFile = (db_export_file: {
+  export_file_id: number
+  export_request_id: number
+  file_name: string
+  created_at: string
+}): z.infer<typeof export_file> => {
+  return {
+    export_request_id: db_export_file.export_request_id as any,
+    export_file_id: db_export_file.export_file_id as any,
+    file_name: db_export_file.file_name,
+    created_at: db_export_file.created_at,
+  }
+}

package/dev-server-api/src/lib/public-mapping/public-map-export-request.ts

@@ -8,12 +8,16 @@ export const publicMapExportRequest = (db_export_request: {
   export_parameters: string
   export_name: string
   is_complete: 1 | 0
+  file_summary?: Array<any>
   created_at: string
 }): z.infer<typeof export_request> => {
   return {
     export_request_id: db_export_request.export_request_id as any,
-    is_completed: db_export_request.is_complete === 1,
+    example_file_path: db_export_request.example_file_path,
+    export_name: db_export_request.export_name,
+    is_complete: db_export_request.is_complete === 1,
+    export_parameters: JSON.parse(db_export_request.export_parameters),
+    file_summary: db_export_request.file_summary,
     created_at: db_export_request.created_at,
-    file_summary: [],
   }
 }

package/dev-server-api/src/lib/zod/export_file.ts

@@ -0,0 +1,8 @@
+import { z } from "zod"
+
+export const export_file = z.object({
+  export_file_id: z.number().int(),
+  export_request_id: z.number().int(),
+  file_name: z.string(),
+  created_at: z.string(),
+})

package/dev-server-api/src/lib/zod/export_parameters.ts

@@ -0,0 +1,10 @@
+import { z } from "zod"
+
+export const export_parameters = z.object({
+  should_export_gerber_zip: z.boolean().default(false),
+  gerbers_zip_file_name: z
+    .string()
+    .nullable()
+    .optional()
+    .default("gerbers.zip"),
+})

package/dev-server-api/src/lib/zod/export_request.ts

@@ -1,13 +1,19 @@
 import { z } from "zod"
+import { export_parameters } from "./export_parameters"
 
 export const export_request = z.object({
   export_request_id: z.coerce.number(),
-  is_completed: z.boolean(),
+  is_complete: z.boolean(),
   created_at: z.string(),
-  file_summary: z.array(
-    z.object({
-      file_name: z.string(),
-      is_complete: z.boolean(),
-    })
-  ),
+  export_name: z.string(),
+  example_file_path: z.string(),
+  export_parameters,
+  file_summary: z
+    .array(
+      z.object({
+        file_name: z.string(),
+        export_file_id: z.number().int(),
+      })
+    )
+    .optional(),
 })

package/dev-server-frontend/src/components/dialogs/gerber-export-dialog.tsx

@@ -45,14 +45,51 @@ export const useGerberExportDialog = () => {
             setExportError(null)
             setIsExporting(true)
             try {
-              await axios.post("/api/export_requests/create", {
-                example_file_path: activeDevExamplePackage.file_path,
-                export_name: activeDevExamplePackage.export_name,
-                export_parameters: {
-                  should_export_gerber_zip: true,
-                  gerbers_zip_file_name: outputName,
-                },
-              })
+              let export_request = await axios
+                .post("/api/export_requests/create", {
+                  example_file_path: activeDevExamplePackage.file_path,
+                  export_name: activeDevExamplePackage.export_name,
+                  export_parameters: {
+                    should_export_gerber_zip: true,
+                    gerbers_zip_file_name: outputName,
+                  },
+                })
+                .then((r) => r.data.export_request)
+
+              const pollExportRequest = async () => {
+                while (!export_request.is_complete) {
+                  try {
+                    export_request = await axios
+                      .post("/api/export_requests/get", {
+                        export_request_id: export_request.export_request_id,
+                      })
+                      .then((r) => r.data.export_request)
+                  } catch (e: any) {
+                    console.error(e)
+                    setExportError(
+                      `${e.toString()}\n\n${e.response?.data?.error?.message}`
+                    )
+                    setIsExporting(false)
+                    return
+                  }
+                  await new Promise((resolve) => setTimeout(resolve, 100))
+                }
+                setIsExporting(false)
+              }
+
+              await pollExportRequest()
+
+              // open /api/export_files/download?export_file_id=... in new tab
+
+              const export_file_id =
+                export_request.file_summary[0].export_file_id
+
+              window.open(
+                `/api/export_files/download?export_file_id=${export_file_id}`,
+                "_blank"
+              )
+
+              setIsExporting(false)
             } catch (e: any) {
               console.error(e)
               setExportError(