@tscircuit/fake-snippets 0.0.120 → 0.0.122

package/fake-snippets-api/routes/api/internal/sessions/create_without_auth.ts

@@ -1,63 +0,0 @@
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-import ms from "ms"
-import { SignJWT } from "jose"
-
-export default withRouteSpec({
-  methods: ["POST"],
-  auth: "none",
-  jsonBody: z
-    .object({
-      account_id: z.string(),
-    })
-    .or(
-      z.object({
-        github_username: z.string(),
-      }),
-    ),
-  jsonResponse: z.object({
-    session: z.object({
-      session_id: z.string(),
-      account_id: z.string(),
-      expires_at: z.string(),
-      is_cli_session: z.boolean(),
-      token: z.string(),
-    }),
-  }),
-})(async (req, ctx) => {
-  let account
-  if ("account_id" in req.jsonBody) {
-    account = ctx.db.getAccount(req.jsonBody.account_id)
-  } else {
-    account = ctx.db.getAccount(req.jsonBody.github_username)
-  }
-
-  if (!account) {
-    return ctx.error(404, {
-      error_code: "account_not_found",
-      message: "Account not found",
-    })
-  }
-
-  const new_session = ctx.db.createSession({
-    expires_at: new Date(Date.now() + ms("60 day")).toISOString(),
-    account_id: account.account_id,
-    is_cli_session: false,
-  })
-
-  const token = await new SignJWT({
-    account_id: account.account_id,
-    session_id: new_session.session_id,
-    github_username: account.github_username,
-  })
-    .setProtectedHeader({ alg: "HS256" })
-    .setExpirationTime(new Date(Date.now() + ms("60 day")).toISOString())
-    .sign(new TextEncoder().encode(process.env.JWT_SECRET || ""))
-
-  return ctx.json({
-    session: {
-      ...new_session,
-      token,
-    },
-  })
-})

package/fake-snippets-api/routes/api/order_files/get.ts

@@ -1,28 +0,0 @@
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-import { orderFileSchema } from "fake-snippets-api/lib/db/schema"
-
-export default withRouteSpec({
-  methods: ["GET"],
-  auth: "session",
-  queryParams: z.object({
-    order_file_id: z.string(),
-  }),
-  jsonResponse: z.object({
-    order_file: orderFileSchema,
-  }),
-})(async (req, ctx) => {
-  const { order_file_id } = req.query
-
-  const orderFile = ctx.db.getOrderFileById(order_file_id)
-  if (!orderFile) {
-    return ctx.error(404, {
-      error_code: "order_file_not_found",
-      message: "Order file not found",
-    })
-  }
-
-  return ctx.json({
-    order_file: orderFile,
-  })
-})

package/fake-snippets-api/routes/api/order_files/upload.ts

@@ -1,46 +0,0 @@
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-import { orderFileSchema } from "fake-snippets-api/lib/db/schema"
-
-export default withRouteSpec({
-  methods: ["POST"],
-  auth: "session",
-  jsonBody: z.object({
-    order_id: z.string(),
-    content_base64: z.string(),
-    is_gerbers_zip: z.boolean().optional(),
-    for_provider: z.string().optional(),
-  }),
-  jsonResponse: z.object({
-    order_file: orderFileSchema,
-  }),
-})(async (req, ctx) => {
-  const { order_id, content_base64, is_gerbers_zip, for_provider } =
-    req.jsonBody
-
-  const order = ctx.db.getOrderById(order_id)
-  if (!order) {
-    return ctx.error(404, {
-      error_code: "order_not_found",
-      message: "Order not found",
-    })
-  }
-
-  const newOrderFile = {
-    order_id,
-    is_gerbers_zip: is_gerbers_zip || false,
-    content_type: "base64",
-    for_provider: for_provider || null,
-    uploaded_at: new Date().toISOString(),
-    content_text: Buffer.from(content_base64, "base64").toString("utf-8"),
-    content_bytes: Uint8Array.from(atob(content_base64), (c) =>
-      c.charCodeAt(0),
-    ),
-  }
-
-  const orderFile = ctx.db.addOrderFile(newOrderFile)
-
-  return ctx.json({
-    order_file: orderFile,
-  })
-})

package/fake-snippets-api/routes/api/order_quotes/create.ts

@@ -1,60 +0,0 @@
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-
-export default withRouteSpec({
-  methods: ["POST"],
-  auth: "session",
-  jsonBody: z.object({
-    package_release_id: z.string(),
-    vendor_name: z.literal("jlcpcb"),
-  }),
-  jsonResponse: z.object({
-    order_quote_id: z.string().optional(),
-    error: z
-      .object({
-        error_code: z.string(),
-        message: z.string(),
-      })
-      .optional(),
-  }),
-})(async (req, ctx) => {
-  const { package_release_id, vendor_name } = req.jsonBody
-
-  // check package release exists
-  const packageRelease = ctx.db.getPackageReleaseById(package_release_id)
-  if (!packageRelease) {
-    return ctx.json(
-      {
-        error: {
-          error_code: "package_release_not_found",
-          message: "Package release not found",
-        },
-      },
-      { status: 404 },
-    )
-  }
-
-  const packageReleaseFiles =
-    ctx.db.getPackageFilesByReleaseId(package_release_id)
-  if (packageReleaseFiles.length === 0) {
-    return ctx.json(
-      {
-        error: {
-          error_code: "package_release_files_not_found",
-          message: "Package release files not found",
-        },
-      },
-      { status: 404 },
-    )
-  }
-
-  const orderQuoteId = ctx.db.addOrderQuote({
-    account_id: ctx.auth.account_id,
-    package_release_id,
-    vendor_name,
-  })
-
-  return ctx.json({
-    order_quote_id: orderQuoteId,
-  })
-})

package/fake-snippets-api/routes/api/order_quotes/create_all_vendor_quotes.ts

@@ -1,30 +0,0 @@
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-
-export default withRouteSpec({
-  methods: ["POST"],
-  auth: "session",
-  jsonBody: z.object({
-    package_release_id: z.string(),
-  }),
-  jsonResponse: z.object({
-    order_quote_ids: z.array(z.string()),
-  }),
-})(async (req, ctx) => {
-  const { package_release_id } = req.jsonBody
-  const vendorNames = ["JLCPCB", "MacroFab"]
-
-  let orderQuoteIds = []
-  for (const vendorName of vendorNames) {
-    const orderQuoteId = ctx.db.addOrderQuote({
-      account_id: ctx.auth.account_id,
-      package_release_id,
-      vendor_name: vendorName,
-    })
-    orderQuoteIds.push(orderQuoteId)
-  }
-
-  return ctx.json({
-    order_quote_ids: orderQuoteIds,
-  })
-})

package/fake-snippets-api/routes/api/order_quotes/get.ts

@@ -1,29 +0,0 @@
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-import { orderQuoteSchema } from "fake-snippets-api/lib/db/schema"
-
-export default withRouteSpec({
-  methods: ["GET", "POST"],
-  auth: "session",
-  commonParams: z.object({
-    order_quote_id: z.string(),
-  }),
-  jsonResponse: z.object({
-    order_quote: orderQuoteSchema,
-  }),
-})(async (req, ctx) => {
-  const { order_quote_id } = req.commonParams
-
-  const orderQuote = ctx.db.getOrderQuoteById(order_quote_id)
-
-  if (!orderQuote) {
-    return ctx.error(404, {
-      error_code: "order_quote_not_found",
-      message: "Order quote not found",
-    })
-  }
-
-  return ctx.json({
-    order_quote: orderQuote,
-  })
-})

package/fake-snippets-api/routes/api/orders/create.ts

@@ -1,70 +0,0 @@
-import {
-  JlcpcbOrderState,
-  type Order,
-  orderSchema,
-} from "fake-snippets-api/lib/db/schema"
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-
-export default withRouteSpec({
-  methods: ["POST"],
-  auth: "session",
-  jsonBody: z
-    .object({
-      package_release_id: z.string().uuid().optional(),
-      circuit_json: z.array(z.record(z.any())),
-    })
-    .refine((data) => data.package_release_id || data.circuit_json, {
-      message: "Either package_release_id or circuit_json must be provided",
-    }),
-  jsonResponse: z.object({
-    order: orderSchema,
-  }),
-})(async (req, ctx) => {
-  const { circuit_json } = req.jsonBody
-
-  const newOrder = {
-    account_id: ctx.auth.account_id,
-    is_running: false,
-    is_started: false,
-    is_finished: false,
-    error: null,
-    has_error: false,
-    created_at: new Date().toISOString(),
-    started_at: null,
-    completed_at: null,
-    circuit_json,
-  }
-
-  const order = ctx.db.addOrder(newOrder)
-
-  const newJlcpcbOrderState = {
-    order_id: order.order_id,
-    created_at: new Date().toISOString(),
-    are_gerbers_uploaded: false,
-    is_gerber_analyzed: false,
-    are_initial_costs_calculated: false,
-    is_pcb_added_to_cart: false,
-    is_bom_uploaded: false,
-    is_pnp_uploaded: false,
-    is_bom_pnp_analyzed: false,
-    is_bom_parsing_complete: false,
-    are_components_available: false,
-    is_patch_map_generated: false,
-    is_json_merge_file_created: false,
-    is_dfm_result_generated: false,
-    are_files_downloaded: false,
-    are_product_categories_fetched: false,
-    are_final_costs_calculated: false,
-    is_json_merge_file_updated: false,
-    is_added_to_cart: false,
-    are_gerbers_generated: false,
-    current_step: null,
-  }
-
-  ctx.db.addJlcpcbOrderState(newJlcpcbOrderState)
-
-  return ctx.json({
-    order,
-  })
-})

package/fake-snippets-api/routes/api/orders/get.ts

@@ -1,168 +0,0 @@
-import {
-  errorSchema,
-  jlcpcbOrderStateSchema,
-  orderSchema,
-} from "fake-snippets-api/lib/db/schema"
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-import { orderSteps as simulateScenarios } from "fake-snippets-api/utils/order-steps"
-
-const defaultOrderState = {
-  are_gerbers_uploaded: false,
-  is_gerber_analyzed: false,
-  are_initial_costs_calculated: false,
-  is_pcb_added_to_cart: false,
-  is_bom_uploaded: false,
-  is_pnp_uploaded: false,
-  is_bom_pnp_analyzed: false,
-  is_bom_parsing_complete: false,
-  are_components_available: false,
-  is_patch_map_generated: false,
-  is_json_merge_file_created: false,
-  is_dfm_result_generated: false,
-  are_files_downloaded: false,
-  are_product_categories_fetched: false,
-  are_final_costs_calculated: false,
-  is_json_merge_file_updated: false,
-  is_added_to_cart: false,
-  uploaded_gerber_metadata: null,
-  gerber_analysis: null,
-  are_gerbers_generated: false,
-  current_step: null as null | (typeof simulateScenarios)[number],
-}
-
-const errorMap = {
-  are_gerbers_generated: {
-    error_code: "GERBER_GENERATION_FAILED",
-    message: "Gerber generation failed",
-  },
-  are_gerbers_uploaded: {
-    error_code: "GERBER_UPLOAD_FAILED",
-    message: "Gerber upload failed",
-  },
-  is_gerber_analyzed: {
-    error_code: "ANALYZE_GERBER_FAILED",
-    message: "Analyze gerber failed",
-  },
-  is_bom_uploaded: {
-    error_code: "BOM_UPLOAD_FAILED",
-    message: "Bom upload failed",
-  },
-  is_pnp_uploaded: {
-    error_code: "PNP_UPLOAD_FAILED",
-    message: "Pnp upload failed",
-  },
-  is_bom_pnp_analyzed: {
-    error_code: "ANALYZE_BOM_AND_PNP_FAILED",
-    message: "Analyze bom and pnp failed",
-  },
-  is_bom_parsing_complete: {
-    error_code: "BOM_PARSING_FAILED",
-    message: "Bom parsing failed",
-  },
-  are_components_available: {
-    error_code: "COMPONENTS_AVAILABILITY_FAILED",
-    message: "Components availability failed",
-  },
-  is_patch_map_generated: {
-    error_code: "GENERATE_PATCH_MAP_FAILED",
-    message: "Generate patch map failed",
-  },
-  is_json_merge_file_created: {
-    error_code: "CREATION_JSON_MERGE_FILE_FAILED",
-    message: "Creation json merge file failed",
-  },
-  is_dfm_result_generated: {
-    error_code: "GENERATE_DFM_RESULT_FAILED",
-    message: "Generate dfm result failed",
-  },
-  are_files_downloaded: {
-    error_code: "DOWNLOAD_FILES_FAILED",
-    message: "Download files failed",
-  },
-  are_product_categories_fetched: {
-    error_code: "FETCH_PRODUCT_CATEGORIES_FAILED",
-    message: "Fetch product categories failed",
-  },
-  are_final_costs_calculated: {
-    error_code: "FINAL_COST_CALCULATION_FAILED",
-    message: "Final cost calculation failed",
-  },
-  is_json_merge_file_updated: {
-    error_code: "UPDATE_JSON_MERGE_FILE_FAILED",
-    message: "Update json merge file failed",
-  },
-  is_pcb_added_to_cart: {
-    error_code: "ADD_PCB_TO_CART_FAILED",
-    message: "Add pcb to cart failed",
-  },
-  is_added_to_cart: {
-    error_code: "ADD_TO_CART_FAILED",
-    message: "Add to cart failed",
-  },
-  are_initial_costs_calculated: {
-    error_code: "INITIAL_COST_CALCULATION_FAILED",
-    message: "Initial cost calculation failed",
-  },
-}
-
-export default withRouteSpec({
-  methods: ["GET"],
-  auth: "session",
-  queryParams: z.object({
-    order_id: z.string(),
-    _simulate_scenario: z.enum(simulateScenarios).optional(),
-  }),
-  jsonResponse: z.object({
-    order: orderSchema,
-    orderState: jlcpcbOrderStateSchema,
-  }),
-})(async (req, ctx) => {
-  const { order_id, _simulate_scenario } = req.query
-
-  const order = ctx.db.getOrderById(order_id)
-  if (!order) {
-    return ctx.error(404, {
-      error_code: "order_not_found",
-      message: "Order not found",
-    })
-  }
-
-  const updatedOrderState = {
-    ...defaultOrderState,
-    order_id,
-    created_at: new Date().toISOString(),
-  }
-
-  if (_simulate_scenario) {
-    const error = errorMap[_simulate_scenario]
-    if (error) {
-      order.error = errorSchema.parse(error)
-      order.has_error = true
-      ctx.db.updateOrder(order_id, { error: order.error, has_error: true })
-
-      const currentIndex = simulateScenarios.indexOf(_simulate_scenario)
-      simulateScenarios.slice(0, currentIndex).forEach((scenario) => {
-        updatedOrderState[scenario] = true
-      })
-      updatedOrderState.current_step = simulateScenarios[currentIndex]
-    }
-  } else {
-    const existingState = ctx.db.getJlcpcbOrderStatesByOrderId(order_id)
-    if (existingState) {
-      return ctx.json({
-        order,
-        orderState: existingState,
-      })
-    }
-  }
-
-  ctx.db.updateJlcpcbOrderState(order_id, updatedOrderState)
-
-  const orderState = ctx.db.getJlcpcbOrderStatesByOrderId(order_id)!
-
-  return ctx.json({
-    order,
-    orderState,
-  })
-})

package/fake-snippets-api/routes/api/orders/list.ts

@@ -1,15 +0,0 @@
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-import { orderSchema } from "fake-snippets-api/lib/db/schema"
-
-export default withRouteSpec({
-  methods: ["GET"],
-  auth: "session",
-  jsonResponse: z.object({
-    orders: z.array(orderSchema),
-  }),
-})(async (req, ctx) => {
-  return ctx.json({
-    orders: ctx.db.orders.filter((o) => o.account_id === ctx.auth.account_id),
-  })
-})

package/fake-snippets-api/routes/api/orgs/add_member.ts

@@ -1,52 +0,0 @@
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-
-export default withRouteSpec({
-  methods: ["GET", "POST"],
-  commonParams: z.object({
-    org_id: z.string(),
-    account_id: z.string().optional(),
-    github_username: z.string().optional(),
-  }),
-  auth: "session",
-  jsonResponse: z.object({}),
-})(async (req, ctx) => {
-  const { org_id, account_id, github_username } = req.commonParams
-
-  const org = ctx.db.getOrg({ org_id }, ctx.auth)
-
-  if (!org) {
-    return ctx.error(404, {
-      error_code: "org_not_found",
-      message: "Organization not found",
-    })
-  }
-
-  if (!org.can_manage_org) {
-    return ctx.error(403, {
-      error_code: "not_authorized",
-      message: "You do not have permission to manage this organization",
-    })
-  }
-
-  let account = ctx.db.accounts.find((acc) => acc.account_id === account_id)
-  if (!account) {
-    account = ctx.db.accounts.find(
-      (acc) => acc.github_username === github_username,
-    )
-  }
-
-  if (!account) {
-    return ctx.error(404, {
-      error_code: "account_not_found",
-      message: "Account not found",
-    })
-  }
-
-  ctx.db.addOrganizationAccount({
-    org_id,
-    account_id: account.account_id,
-  })
-
-  return ctx.json({})
-})

package/fake-snippets-api/routes/api/orgs/create.ts

@@ -1,48 +0,0 @@
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-import { publicMapOrg } from "fake-snippets-api/lib/public-mapping/public-map-org"
-import { publicOrgSchema } from "fake-snippets-api/lib/db/schema"
-
-export default withRouteSpec({
-  methods: ["GET", "POST"],
-  commonParams: z.object({
-    name: z.string(),
-    github_handle: z.string().optional(),
-  }),
-  auth: "session",
-  jsonResponse: z.object({
-    org: publicOrgSchema,
-  }),
-})(async (req, ctx) => {
-  const { name, github_handle } = req.commonParams
-
-  const existing = ctx.db.getOrg({ org_name: name })
-
-  if (existing) {
-    return ctx.error(400, {
-      error_code: "org_already_exists",
-      message: "An organization with this name already exists",
-    })
-  }
-  const newOrg = {
-    owner_account_id: ctx.auth.account_id,
-    name: name,
-    created_at: new Date(),
-    can_manage_org: true,
-    ...(github_handle ? { github_handle } : {}),
-  }
-
-  const org = ctx.db.addOrganization(newOrg)
-
-  // Add the creator as a member of the organization
-  ctx.db.addOrganizationAccount({
-    org_id: org.org_id,
-    account_id: ctx.auth.account_id,
-    is_owner: true,
-  })
-
-  const fullOrg = ctx.db.getOrg({ org_id: org.org_id }, ctx.auth)
-  return ctx.json({
-    org: publicMapOrg(fullOrg!),
-  })
-})

package/fake-snippets-api/routes/api/orgs/get.ts

@@ -1,39 +0,0 @@
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-import { publicMapOrg } from "fake-snippets-api/lib/public-mapping/public-map-org"
-import { publicOrgSchema } from "fake-snippets-api/lib/db/schema"
-
-export default withRouteSpec({
-  methods: ["GET", "POST"],
-  commonParams: z
-    .object({ org_id: z.string() })
-    .or(z.object({ org_name: z.string() }))
-    .or(z.object({ github_handle: z.string() })),
-  auth: "optional_session",
-  jsonResponse: z.object({
-    org: publicOrgSchema,
-  }),
-})(async (req, ctx) => {
-  const params = req.commonParams as {
-    org_id?: string
-    org_name?: string
-    github_handle?: string
-  }
-
-  const org = ctx.db.getOrg(
-    {
-      org_id: params.org_id,
-      org_name: params.org_name,
-      github_handle: params.github_handle,
-    },
-    ctx.auth,
-  )
-
-  if (!org) {
-    return ctx.error(404, {
-      error_code: "org_not_found",
-      message: "Organization not found",
-    })
-  }
-  return ctx.json({ org: publicMapOrg(org) })
-})