@tscircuit/cli 0.0.394 → 0.1.1

package/api/db/zod-level-db.ts

@@ -1,148 +0,0 @@
-// import { Level } from "level"
-// import { GenericJsonLevel } from "./generic-json-level"
-import { MemoryLevel } from "memory-level"
-import { z } from "zod"
-import { DBSchema, type DBSchemaType, type DBInputSchemaType } from "./schema"
-
-// Create a wrapper class for Level with Zod validation
-export class ZodLevelDatabase {
-  private db: MemoryLevel<string, any>
-
-  constructor(location: string) {
-    this.db = new MemoryLevel() // new GenericJsonLevel(location)
-  }
-
-  async open() {
-    return this.db.open()
-  }
-
-  async close() {
-    return this.db.close()
-  }
-
-  async get<K extends keyof DBSchemaType>(
-    collection: K,
-    id: string | number,
-  ): Promise<DBSchemaType[K] | null> {
-    const key = `${collection}:${id}`
-    const data = await this.db.get(key).catch((e) => null)
-    if (!data) return null
-    return DBSchema.shape[collection].parse(JSON.parse(data)) as any
-  }
-
-  async put<K extends keyof DBSchemaType>(
-    collection: K,
-    value: DBInputSchemaType[K],
-  ): Promise<DBSchemaType[K]> {
-    const idkey = `${collection}_id`
-    const valueLoose: any = value
-    if (!valueLoose[idkey]) {
-      // generate an id using the "count" key
-      let count = await this.db.get(`${collection}.count`).catch(() => 1)
-      if (typeof count === "string") count = parseInt(count)
-      ;(value as any)[idkey] = count
-      await this.db.put(`${collection}.count`, (count + 1).toString())
-    }
-    const key = `${collection}:${valueLoose[idkey]}`
-    const validatedData = DBSchema.shape[collection].parse(value)
-    await this.db.put(key, JSON.stringify(validatedData))
-    return validatedData as DBSchemaType[K]
-  }
-
-  async del<K extends keyof DBSchemaType>(
-    collection: K,
-    id: string,
-  ): Promise<void> {
-    const key = `${collection}:${id}`
-    await this.db.del(key)
-  }
-
-  async find<K extends keyof DBSchemaType>(
-    collection: K,
-    partialObject: Partial<DBSchemaType[K]>,
-  ): Promise<DBSchemaType[K] | null> {
-    const schema = DBSchema.shape[collection]
-
-    for await (const [key, value] of this.db.iterator({
-      gte: `${collection}:`,
-      lte: `${collection}:\uffff`,
-    })) {
-      try {
-        const parsedValue = schema.parse(JSON.parse(value))
-        if (this.matchesPartialObject(parsedValue, partialObject)) {
-          return parsedValue as any
-        }
-      } catch (error) {
-        console.error(`Error parsing value for key ${key}:`, error)
-      }
-    }
-
-    return null
-  }
-
-  async findOrThrow<K extends keyof DBSchemaType>(
-    collection: K,
-    partialObject: Partial<DBSchemaType[K]>,
-  ): Promise<DBSchemaType[K]> {
-    const result = await this.find(collection, partialObject)
-    if (!result) {
-      throw new Error(
-        `No record in "${collection}" matches query ${JSON.stringify(
-          partialObject,
-        )}`,
-      )
-    }
-    return result
-  }
-
-  private matchesPartialObject<T>(
-    fullObject: T,
-    partialObject: Partial<T>,
-  ): boolean {
-    for (const [key, value] of Object.entries(partialObject)) {
-      if (fullObject[key as keyof T] !== value) {
-        return false
-      }
-    }
-    return true
-  }
-
-  async dump(): Promise<DBSchemaType> {
-    // Serialize all data in the database
-    const dump: any = {}
-    for await (const [key, value] of this.db.iterator({})) {
-      const [collection, id] = key.split(":")
-      if (!dump[collection]) {
-        dump[collection] = {}
-      }
-      dump[collection][id] = JSON.parse(value)
-    }
-    return dump
-  }
-
-  async list<K extends keyof DBSchemaType>(
-    collection: K,
-  ): Promise<DBSchemaType[K][]> {
-    const schema = DBSchema.shape[collection]
-    const results: DBSchemaType[K][] = []
-
-    for await (const [key, value] of this.db.iterator({
-      gte: `${collection}:`,
-      lte: `${collection}:\uffff`,
-    })) {
-      if (key.endsWith(".count")) continue
-      try {
-        const parsedValue = schema.parse(JSON.parse(value))
-        results.push(parsedValue as DBSchemaType[K])
-      } catch (error) {
-        console.error(`Error parsing value for key ${key}:`, error)
-      }
-    }
-
-    return results
-  }
-
-  async clear() {
-    return this.db.clear()
-  }
-}

package/api/index.ts

@@ -1,4 +0,0 @@
-import { createWinterSpecFromRouteMap } from "winterspec/adapters/node"
-import staticRoutes from "./static-routes"
-
-export default await createWinterSpecFromRouteMap(staticRoutes)

package/api/lib/middlewares/with-db.ts

@@ -1,18 +0,0 @@
-import type { Middleware } from "winterspec"
-import { getDb } from "api/db/get-db"
-import type { ZodLevelDatabase } from "api/db/zod-level-db"
-
-export const withDb: Middleware<
-  {},
-  {
-    db: ZodLevelDatabase
-  }
-> = async (req, ctx, next) => {
-  if (!ctx.db) {
-    ctx.db = await getDb()
-  }
-  // await ctx.db.open()
-  const res = await next(req, ctx)
-  // await ctx.db.close()
-  return res
-}

package/api/lib/middlewares/with-debug-request-logging.ts

@@ -1,13 +0,0 @@
-import type { Middleware } from "winterspec"
-import Debug from "debug"
-
-const debug = Debug("tscircuit:cli:api")
-
-export const withDebugRequestLogging: Middleware<{}, {}> = async (
-  req,
-  ctx,
-  next,
-) => {
-  debug(`[REQ] ${req.method?.toUpperCase()} ${req.url}`)
-  return next(req, ctx)
-}

package/api/lib/middlewares/with-error-response.ts

@@ -1,37 +0,0 @@
-import { NotFoundError, type Middleware } from "winterspec/middleware"
-import kleur from "kleur"
-
-export const withErrorResponse: Middleware<{}, {}> = async (req, ctx, next) => {
-  try {
-    return await next(req, ctx)
-  } catch (error: any) {
-    // If error is a Response, return it
-    if (error instanceof Response) {
-      return error
-    }
-    if (error instanceof NotFoundError) {
-      return (ctx as any).json(
-        {
-          ok: false,
-          error: {
-            message: error?.message,
-            error_code: "not_found",
-          },
-        },
-        { status: error?.status || 404 },
-      )
-    }
-
-    console.error(kleur.red("Intercepted unhandled error:"), error)
-    return (ctx as any).json(
-      {
-        ok: false,
-        error: {
-          message: error?.message,
-          error_code: error?.error_code ?? "internal_server_error",
-        },
-      },
-      { status: error?.status || 500 },
-    )
-  }
-}

package/api/lib/with-winter-spec.ts

@@ -1,9 +0,0 @@
-import { createWithWinterSpec } from "winterspec"
-import { withDb } from "./middlewares/with-db"
-import { withErrorResponse } from "./middlewares/with-error-response"
-import { withDebugRequestLogging } from "./middlewares/with-debug-request-logging"
-
-export const withWinterSpec = createWithWinterSpec({
-  authMiddleware: {},
-  beforeAuthMiddleware: [withDebugRequestLogging, withErrorResponse, withDb],
-})

package/api/lib/zod/export_parameters.ts

@@ -1,25 +0,0 @@
-import { z } from "zod"
-
-export const export_parameters = z.object({
-  should_export_gerber_zip: z.boolean().default(false),
-  should_export_pnp_csv: z.boolean().default(false),
-  should_export_bom_csv: z.boolean().default(false),
-  should_export_soup_json: z.boolean().default(false),
-  should_export_kicad_pcb: z.boolean().default(false),
-  gerbers_zip_file_name: z
-    .string()
-    .nullable()
-    .optional()
-    .default("gerbers.zip"),
-  pnp_csv_file_name: z.string().nullable().optional().default("pnp.csv"),
-  bom_csv_file_name: z.string().nullable().optional().default("bom.csv"),
-  soup_json_file_name: z.string().nullable().optional().default("soup.json"),
-  kicad_pcb_file_name: z
-    .string()
-    .nullable()
-    .optional()
-    .default("output.kicad_pcb"),
-})
-
-export type ExportParametersInput = z.input<typeof export_parameters>
-export type ExportParameters = z.infer<typeof export_parameters>

package/api/routes/api/db/download.ts

@@ -1,25 +0,0 @@
-import { withWinterSpec } from "api/lib/with-winter-spec"
-import { z } from "zod"
-
-export default withWinterSpec({
-  methods: ["GET"],
-  jsonResponse: z.object({
-    dev_server_database_dump: z.any(),
-  }),
-  auth: "none",
-})(async (req, ctx) => {
-  return new Response(
-    JSON.stringify(
-      {
-        dev_server_database_dump: await ctx.db.dump(),
-      },
-      null,
-      "  ",
-    ),
-    {
-      headers: {
-        "content-type": "application/json",
-      },
-    },
-  )
-})

package/api/routes/api/dev_package_examples/create.ts

@@ -1,43 +0,0 @@
-import { withWinterSpec } from "api/lib/with-winter-spec"
-import { z } from "zod"
-
-export default withWinterSpec({
-  methods: ["POST"],
-  jsonBody: z.object({
-    file_path: z.string(),
-    export_name: z.string().default("default"),
-    tscircuit_soup: z.any(),
-    error: z.string().nullable().optional().default(null),
-    is_loading: z.boolean().optional(),
-  }),
-  jsonResponse: z.object({
-    dev_package_example: z.object({
-      dev_package_example_id: z.coerce.number(),
-      file_path: z.string(),
-      tscircuit_soup: z.any(),
-      error: z.string().nullable().optional(),
-      last_updated_at: z.string().datetime().nullable(), // TODO remove nullable
-    }),
-  }),
-  auth: "none",
-})(async (req, ctx) => {
-  const tscircuit_soup = req.jsonBody.tscircuit_soup
-
-  const existingDevPackageExample = await ctx.db.find("dev_package_example", {
-    file_path: req.jsonBody.file_path,
-  })
-
-  const dev_package_example = await ctx.db.put("dev_package_example", {
-    ...existingDevPackageExample,
-    file_path: req.jsonBody.file_path,
-    export_name: req.jsonBody.export_name,
-    error: req.jsonBody.error,
-    tscircuit_soup,
-    is_loading: Boolean(req.jsonBody.is_loading),
-    last_updated_at: new Date().toISOString(),
-  })
-
-  return ctx.json({
-    dev_package_example,
-  })
-})

package/api/routes/api/dev_package_examples/get.ts

@@ -1,46 +0,0 @@
-import { withWinterSpec } from "api/lib/with-winter-spec"
-import { NotFoundError } from "winterspec/middleware"
-import { z } from "zod"
-
-export default withWinterSpec({
-  methods: ["GET", "POST"],
-  commonParams: z.object({
-    dev_package_example_id: z.coerce.number(),
-  }),
-  jsonResponse: z.object({
-    dev_package_example: z.object({
-      dev_package_example_id: z.coerce.number(),
-      file_path: z.string(),
-      tscircuit_soup: z.any(),
-      completed_edit_events: z.array(z.any()).default([]),
-      is_loading: z.boolean(),
-      error: z.string().nullable().optional().default(null),
-      soup_last_updated_at: z.string().datetime().nullable().default(null),
-      edit_events_last_updated_at: z
-        .string()
-        .datetime()
-        .nullable()
-        .default(null),
-      edit_events_last_applied_at: z
-        .string()
-        .datetime()
-        .nullable()
-        .default(null),
-      last_updated_at: z.string().datetime().nullable(),
-    }),
-  }),
-  auth: "none",
-})(async (req, ctx) => {
-  const dev_package_example = await ctx.db.get(
-    "dev_package_example",
-    req.commonParams.dev_package_example_id,
-  )
-
-  if (!dev_package_example) {
-    return new Response("Package not found", { status: 404 })
-  }
-
-  return ctx.json({
-    dev_package_example,
-  })
-})

package/api/routes/api/dev_package_examples/list.ts

@@ -1,36 +0,0 @@
-import { withWinterSpec } from "api/lib/with-winter-spec"
-import { z } from "zod"
-
-export default withWinterSpec({
-  methods: ["GET", "POST"],
-  jsonResponse: z.object({
-    dev_package_examples: z.array(
-      z.object({
-        dev_package_example_id: z.coerce.number(),
-        file_path: z.string(),
-        export_name: z.string().nullable(),
-        is_loading: z.boolean(),
-        edit_events_last_updated_at: z.string().datetime().nullable(),
-        soup_last_updated_at: z.string().datetime().nullable(),
-        last_updated_at: z.string().datetime().nullable(),
-      }),
-    ),
-  }),
-  auth: "none",
-})(async (req, ctx) => {
-  const dev_package_examples = (await ctx.db.list("dev_package_example")).map(
-    (dpe) => ({
-      dev_package_example_id: dpe.dev_package_example_id,
-      file_path: dpe.file_path,
-      export_name: dpe.export_name,
-      is_loading: dpe.is_loading,
-      edit_events_last_updated_at: dpe.edit_events_last_updated_at,
-      soup_last_updated_at: dpe.soup_last_updated_at,
-      last_updated_at: dpe.last_updated_at,
-    }),
-  )
-
-  return ctx.json({
-    dev_package_examples,
-  })
-})

package/api/routes/api/dev_package_examples/update.ts

@@ -1,59 +0,0 @@
-import { withWinterSpec } from "api/lib/with-winter-spec"
-import { NotFoundError } from "winterspec/middleware"
-import { z } from "zod"
-import { DevPackageExampleSchema } from "api/db/schema"
-
-export default withWinterSpec({
-  methods: ["POST"],
-  jsonBody: z.object({
-    dev_package_example_id: z.coerce.number(),
-    tscircuit_soup: z.any().optional(),
-    completed_edit_events: z.array(z.any()).optional(),
-    edit_events_last_applied_at: z.string().datetime().optional(),
-    error: z.string().nullable().optional().default(null),
-  }),
-  jsonResponse: z.object({
-    dev_package_example: DevPackageExampleSchema,
-  }),
-  auth: "none",
-})(async (req, ctx) => {
-  const dev_package_example = await ctx.db.get(
-    "dev_package_example",
-    req.jsonBody.dev_package_example_id,
-  )
-
-  if (!dev_package_example) {
-    return new Response("Package not found", { status: 404 })
-  }
-
-  const new_dev_package_example = {
-    ...dev_package_example,
-  }
-
-  if (req.jsonBody.completed_edit_events !== undefined) {
-    new_dev_package_example.completed_edit_events =
-      req.jsonBody.completed_edit_events
-    new_dev_package_example.edit_events_last_updated_at =
-      new Date().toISOString()
-  }
-  if (req.jsonBody.edit_events_last_applied_at !== undefined) {
-    new_dev_package_example.edit_events_last_applied_at =
-      req.jsonBody.edit_events_last_applied_at
-  }
-  if (req.jsonBody.tscircuit_soup !== undefined) {
-    new_dev_package_example.tscircuit_soup = req.jsonBody.tscircuit_soup
-    new_dev_package_example.error = null
-    new_dev_package_example.soup_last_updated_at = new Date().toISOString()
-  }
-  if (req.jsonBody.error !== undefined) {
-    new_dev_package_example.error = req.jsonBody.error
-  }
-
-  new_dev_package_example.last_updated_at = new Date().toISOString()
-
-  await ctx.db.put("dev_package_example", new_dev_package_example)
-
-  return ctx.json({
-    dev_package_example: new_dev_package_example,
-  })
-})

package/api/routes/api/dev_server/reset.ts

@@ -1,13 +0,0 @@
-import { withWinterSpec } from "api/lib/with-winter-spec"
-
-export default withWinterSpec({
-  methods: ["GET", "POST"],
-  auth: "none",
-})(async (req, ctx) => {
-  await ctx.db.clear()
-  return new Response(JSON.stringify({}), {
-    headers: {
-      "content-type": "application/json",
-    },
-  })
-})

package/api/routes/api/export_files/create.ts

@@ -1,27 +0,0 @@
-import { ExportFileSchema } from "api/db/schema"
-import { withWinterSpec } from "api/lib/with-winter-spec"
-import { z } from "zod"
-
-export default withWinterSpec({
-  methods: ["POST"],
-  jsonBody: z.object({
-    export_request_id: z.number().int(),
-    file_name: z.string(),
-    file_content_base64: z.string(),
-  }),
-  jsonResponse: z.object({
-    export_file: ExportFileSchema.omit({ file_content_base64: true }),
-  }),
-  auth: "none",
-})(async (req, ctx) => {
-  const export_file = await ctx.db.put("export_file", {
-    export_request_id: req.jsonBody.export_request_id,
-    file_name: req.jsonBody.file_name,
-    file_content_base64: req.jsonBody.file_content_base64,
-    created_at: new Date().toISOString(),
-  })
-  console.log("done putting file")
-  return ctx.json({
-    export_file,
-  })
-})

package/api/routes/api/export_files/download.ts

@@ -1,25 +0,0 @@
-import { withWinterSpec } from "api/lib/with-winter-spec"
-import { NotFoundError } from "winterspec/middleware"
-import { z } from "zod"
-
-export default withWinterSpec({
-  methods: ["GET"],
-  queryParams: z.object({
-    export_file_id: z.coerce.number().int(),
-  }),
-  auth: "none",
-})(async (req, ctx) => {
-  const export_file = await ctx.db.get("export_file", req.query.export_file_id)
-
-  if (!export_file) {
-    throw new NotFoundError("Export file not found")
-  }
-
-  const file_content = Buffer.from(export_file.file_content_base64!, "base64")
-
-  return new Response(file_content, {
-    headers: {
-      "Content-Disposition": `attachment; filename="${export_file.file_name}"`,
-    },
-  })
-})

package/api/routes/api/export_requests/create.ts

@@ -1,30 +0,0 @@
-import { withWinterSpec } from "api/lib/with-winter-spec"
-import { z } from "zod"
-import { export_parameters } from "api/lib/zod/export_parameters"
-import { ExportRequestSchema } from "api/db/schema"
-
-export default withWinterSpec({
-  methods: ["POST"],
-  jsonBody: z.object({
-    example_file_path: z.string(),
-    export_name: z.string().nullable().optional(),
-    export_parameters: export_parameters,
-  }),
-  jsonResponse: z.object({
-    export_request: ExportRequestSchema,
-  }),
-  auth: "none",
-})(async (req, ctx) => {
-  const export_request = await ctx.db.put("export_request", {
-    example_file_path: req.jsonBody.example_file_path,
-    export_parameters: req.jsonBody.export_parameters,
-    export_name: req.jsonBody.export_name ?? "default",
-    is_complete: false,
-    has_error: false,
-    created_at: new Date().toISOString(),
-  })
-
-  return ctx.json({
-    export_request,
-  })
-})

package/api/routes/api/export_requests/get.ts

@@ -1,43 +0,0 @@
-import { withWinterSpec } from "api/lib/with-winter-spec"
-import { z } from "zod"
-import { NotFoundError } from "winterspec/middleware"
-import { ExportRequestSchema } from "api/db/schema"
-
-export default withWinterSpec({
-  methods: ["GET", "POST"],
-  commonParams: z.object({
-    export_request_id: z.coerce.number(),
-  }),
-  jsonResponse: z.object({
-    export_request: ExportRequestSchema.extend({
-      file_summary: z.array(
-        z.object({ file_name: z.string(), export_file_id: z.coerce.number() }),
-      ),
-    }),
-  }),
-  auth: "none",
-})(async (req, ctx) => {
-  const { export_request_id } = req.commonParams
-  const export_request = await ctx.db.get("export_request", export_request_id)
-
-  if (!export_request) {
-    throw new NotFoundError("Export request not found")
-  }
-
-  const ext_export_request: Parameters<typeof ctx.json>[0]["export_request"] = {
-    ...export_request,
-    file_summary: undefined as any,
-  }
-
-  const export_files = (await ctx.db.list("export_file")).filter(
-    (ef) => ef.export_request_id === export_request_id,
-  )
-  ext_export_request.file_summary = export_files.map((ef) => ({
-    file_name: ef.file_name!,
-    export_file_id: ef.export_file_id,
-  }))
-
-  return ctx.json({
-    export_request: ext_export_request,
-  })
-})

package/api/routes/api/export_requests/list.ts

@@ -1,26 +0,0 @@
-import { withWinterSpec } from "api/lib/with-winter-spec"
-import { z } from "zod"
-import { ExportRequestSchema } from "api/db/schema"
-
-export default withWinterSpec({
-  methods: ["GET", "POST"],
-  commonParams: z.object({
-    is_complete: z.boolean().nullable().default(null),
-  }),
-  jsonResponse: z.object({
-    export_requests: z.array(ExportRequestSchema),
-  }),
-  auth: "none",
-})(async (req, ctx) => {
-  const { is_complete } = req.commonParams
-  const db_export_requests = await ctx.db.list("export_request")
-
-  const filtered_requests =
-    is_complete === null
-      ? db_export_requests
-      : db_export_requests.filter((er) => er.is_complete === is_complete)
-
-  return ctx.json({
-    export_requests: filtered_requests,
-  })
-})

package/api/routes/api/export_requests/update.ts

@@ -1,34 +0,0 @@
-import { withWinterSpec } from "api/lib/with-winter-spec"
-import { NotFoundError } from "winterspec/middleware"
-import { z } from "zod"
-import { ExportRequestSchema } from "api/db/schema"
-
-export default withWinterSpec({
-  methods: ["POST"],
-  jsonBody: z.object({
-    export_request_id: z.coerce.number(),
-    is_complete: z.boolean().optional(),
-    has_error: z.boolean().optional(),
-    error: z.string().optional(),
-  }),
-  jsonResponse: z.object({
-    export_request: ExportRequestSchema,
-  }),
-  auth: "none",
-})(async (req, ctx) => {
-  const { export_request_id, ...updateData } = req.jsonBody
-  const existingRequest = await ctx.db.get("export_request", export_request_id)
-
-  if (!existingRequest) {
-    throw new NotFoundError("Export request not found")
-  }
-
-  const updatedRequest = await ctx.db.put("export_request", {
-    ...existingRequest,
-    ...updateData,
-  })
-
-  return ctx.json({
-    export_request: updatedRequest,
-  })
-})