feat: add type search

apps/backend/src/api/signatures.gleam

@@ -8,9 +8,12 @@ import backend/gleam/generate/types.{
  constant_to_json, function_to_json, type_alias_to_json,
  type_definition_to_json,
 }
+import backend/gleam/type_search/state as type_search
 import backend/postgres/queries
 import gleam/bool
 import gleam/dict
+import gleam/erlang/process
+import gleam/function
 import gleam/json
 import gleam/list
 import gleam/option.{None, Some}
@@ -132,20 +135,30 @@ fn upsert_functions(ctx: Context, module: context.Module) {
  result.all({
  use #(function_name, function) <- list.map(all_functions)
  use gen <- result.try(function_to_json(ctx, function_name, function))
+ let signature = function_to_string(function_name, function)
  queries.upsert_package_type_fun_signature(
  db: ctx.db,
  name: function_name,
  kind: queries.Function,
  documentation: function.documentation,
  metadata: Some(function.implementations)
  |> metadata.generate(function.deprecation, _),
- signature: function_to_string(function_name, function),
+ signature: signature,
  json_signature: gen.0,
  parameters: gen.1,
  module_id: module.id,
  deprecation: function.deprecation,
  implementations: Some(function.implementations),
  )
+ |> function.tap(fn(content) {
+ case ctx.type_search_subject, content {
+ option.Some(subject), Ok([id]) -> {
+ process.send(subject, type_search.Add(signature, id))
+ content
+ }
+ _, _ -> content
+ }
+ })
  })
 }
 

apps/backend/src/backend.gleam

@@ -1,4 +1,5 @@
 import backend/config
+import backend/gleam/type_search/state as type_search
 import backend/postgres/postgres
 import backend/router
 import dot_env
@@ -25,6 +26,15 @@ pub fn main() {
  logger.set_level(cnf.level)
  setup.radiate()
 
+ let assert Ok(subject) = type_search.init(ctx.db)
+ // let assert Ok(_) =
+ // supervisor.start(fn(children) {
+ // use _ <- function.tap(children)
+ // supervisor.add(children, { supervisor.worker(fn(_) { Ok(subject) }) })
+ // })
+
+ let ctx = ctx |> config.add_type_search_subject(subject)
+
  let assert Ok(_) =
  router.handle_request(_, ctx)
  |> wisp.mist_handler(secret_key_base)

apps/backend/src/backend/config.gleam

@@ -1,5 +1,8 @@
+import backend/gleam/type_search/state as type_search
 import gleam/erlang/os
+import gleam/erlang/process.{type Subject}
 import gleam/int
+import gleam/option.{type Option}
 import gleam/pgo
 import gleam/result
 import wisp
@@ -16,6 +19,7 @@ pub type Context {
  hex_api_key: String,
  github_token: String,
  env: Environment,
+ type_search_subject: Option(Subject(type_search.Msg)),
  )
 }
 
@@ -66,3 +70,7 @@ pub fn scaleway_keys() {
  let assert Ok(secret_key) = os.get_env("SCALEWAY_SECRET_KEY")
  #(access_key, secret_key)
 }
+
+pub fn add_type_search_subject(context, subject) {
+ Context(..context, type_search_subject: option.Some(subject))
+}

apps/backend/src/backend/gleam/context.gleam

@@ -1,4 +1,7 @@
+import backend/gleam/type_search/state as type_search
 import gleam/dict.{type Dict}
+import gleam/erlang/process.{type Subject}
+import gleam/option.{type Option}
 import gleam/package_interface
 import gleam/pgo
 import tom
@@ -11,6 +14,7 @@ pub type Context {
  /// Allow to bypass parameters relations if activated.
  /// This allows to ignore internals for example.
  ignore_parameters_errors: Bool,
+ type_search_subject: Option(Subject(type_search.Msg)),
  )
 }
 

apps/backend/src/backend/gleam/parse.gleam

@@ -2,7 +2,6 @@ import chomp.{do, return}
 import chomp/lexer
 import chomp/span
 import gleam/dict.{type Dict}
-import gleam/io
 import gleam/list
 import gleam/option.{None, Some}
 import gleam/pair
@@ -14,23 +13,9 @@ pub type Kind {
  Index(String, Int)
  Custom(String, List(Kind))
  Function(List(Kind), Kind)
+ Tuple(List(Kind))
 }
 
-pub fn main() {
- "fn inner_text(plinth/browser/element.Element) -> String"
- |> parse_function
- |> io.debug
-}
-
-// pub type SigKind(a) {
-// Kind(Kind)
-// Fn(a)
-// }
-
-// pub type Signature {
-// Signature(children: Dict(Kind(Signature), List(Signature)), rows: List(Int))
-// }
-
 fn parse_qualified_name() {
  parse_upper_name()
  |> chomp.then(fn(content) {
@@ -62,39 +47,67 @@ fn parse_name() {
  }
 }
 
+fn parse_label() {
+ chomp.backtrackable({
+ use name <- do(
+ chomp.take_map(fn(token) {
+ case token {
+ token.Name(content) -> Some(Index(content, 0))
+ _ -> None
+ }
+ }),
+ )
+ use _ <- do(chomp.token(token.Colon))
+ return(name)
+ })
+}
+
 fn parse_type_parameter() {
  use _ <- do(chomp.token(token.LeftParen))
- use content <- do(
- chomp.one_of([parse_qualified_name(), parse_name()])
- |> chomp.sequence(chomp.token(token.Comma)),
- )
+ use content <- do(parse_kind() |> chomp.sequence(chomp.token(token.Comma)))
  use _ <- do(chomp.token(token.RightParen))
  return(content)
 }
 
 fn parse_return() {
  use _ <- do(chomp.token(token.RightArrow))
- use content <- do(parse_upper_name())
+ use content <- do(parse_kind())
  return(content)
 }
 
+fn parse_tuple() {
+ use _ <- do(chomp.token(token.Hash))
+ use _ <- do(chomp.token(token.LeftParen))
+ use content <- do(parse_kind() |> chomp.sequence(chomp.token(token.Comma)))
+ use _ <- do(chomp.token(token.RightParen))
+ return(Tuple(content))
+}
+
 fn parse_fn() {
  use _ <- do(chomp.token(token.Fn))
  use _ <- do(chomp.optional(parse_name()))
- use _ <- do(chomp.token(token.LeftParen))
+ use _ <- do(chomp.optional(chomp.token(token.LeftParen)))
  use content <- do(
- chomp.one_of([
- parse_fn(),
- chomp.backtrackable(parse_qualified_name()),
- parse_name(),
- ])
+ {
+ use _ <- do(chomp.optional(parse_label()))
+ parse_kind()
+ }
  |> chomp.sequence(chomp.token(token.Comma)),
  )
- use _ <- do(chomp.token(token.RightParen))
+ use _ <- do(chomp.optional(chomp.token(token.RightParen)))
  use content_ <- do(parse_return())
  return(Function(content, content_))
 }
 
+fn parse_kind() {
+ chomp.one_of([
+ parse_fn(),
+ parse_tuple(),
+ chomp.backtrackable(parse_qualified_name()),
+ parse_name(),
+ ])
+}
+
 pub fn parse_function(input: String) {
  let tokens =
  input
@@ -141,5 +154,13 @@ fn replace_indexed(
  let #(return_value, accs) = replace_indexed(accs, return_value)
  #(Function(list.reverse(new_kinds), return_value), accs)
  }
+ Tuple(kinds) -> {
+ let #(new_kinds, accs) =
+ list.fold(kinds, #([], #(indexes, current)), fn(acc, val) {
+ let res = replace_indexed(acc.1, val)
+ #([res.0, ..acc.0], res.1)
+ })
+ #(Tuple(list.reverse(new_kinds)), accs)
+ }
  }
 }

apps/backend/src/backend/gleam/type_search.gleam

@@ -30,7 +30,13 @@ fn do_add(searches: TypeSearch, kinds: List(#(Kind, option.Option(Int)))) {
  [#(kind, option.Some(id))] ->
  dict.get(searches.entries, kind)
  |> result.unwrap(empty())
- |> fn(s) { TypeSearch(..s, rows: [id, ..s.rows]) }
+ |> fn(s: TypeSearch) {
+ let rows = case list.contains(s.rows, id) {
+ True -> s.rows
+ False -> [id, ..s.rows]
+ }
+ TypeSearch(..s, rows: rows)
+ }
  |> dict.insert(searches.entries, kind, _)
  |> fn(a) { TypeSearch(..searches, entries: a) }
  [#(kind, _), ..rest] ->

apps/backend/src/backend/gleam/type_search/state.gleam

@@ -0,0 +1,85 @@
+import backend/gleam/parse
+import backend/gleam/type_search.{type TypeSearch}
+import gleam/bool
+import gleam/dynamic
+import gleam/erlang/process.{type Subject}
+import gleam/function
+import gleam/list
+import gleam/option.{type Option}
+import gleam/otp/actor
+import gleam/pgo
+import gleam/result
+
+pub type State {
+ State(db: pgo.Connection, search: TypeSearch)
+}
+
+pub type Msg {
+ Find(Subject(Option(List(Int))), String)
+ Add(String, Int)
+}
+
+pub fn init(db: pgo.Connection) {
+ let init = fn() {
+ let search =
+ compute_rows(0, db, #(0, type_search.empty()), {
+ fn(search: #(Int, TypeSearch), row: #(String, Int)) {
+ let #(signature, id) = row
+ signature
+ |> parse.parse_function
+ |> result.map(fn(kind) {
+ #(search.0 + 1, type_search.add(search.1, kind, id))
+ })
+ |> result.unwrap(search)
+ }
+ })
+ process.new_selector()
+ |> process.selecting(process.new_subject(), function.identity)
+ |> actor.Ready(State(db, search.1), _)
+ }
+ actor.start_spec(actor.Spec(init, init_timeout: 10_000, loop: loop))
+}
+
+fn loop(msg: Msg, state: State) -> actor.Next(Msg, State) {
+ case msg {
+ Find(subject, signature) -> {
+ signature
+ |> parse.parse_function
+ |> result.map(type_search.find(state.search, _))
+ |> result.unwrap(option.None)
+ |> function.tap(fn(res) { process.send(subject, res) })
+ actor.continue(state)
+ }
+ Add(signature, id) -> {
+ signature
+ |> parse.parse_function
+ |> result.map(fn(kind) { type_search.add(state.search, kind, id) })
+ |> result.unwrap(state.search)
+ |> fn(s) { State(..state, search: s) }
+ |> actor.continue
+ }
+ }
+ actor.continue(state)
+}
+
+fn compute_rows(
+ offset: Int,
+ db: pgo.Connection,
+ default: a,
+ next: fn(a, #(String, Int)) -> a,
+) {
+ let decoder = dynamic.tuple2(dynamic.string, dynamic.int)
+ let rows =
+ "SELECT signature_, id
+ FROM package_type_fun_signature
+ WHERE kind = 'function'
+ ORDER BY id ASC
+ LIMIT 1000
+ OFFSET $1"
+ |> pgo.execute(db, [pgo.int(offset)], decoder)
+ |> result.map(fn(r) { r.rows })
+ |> result.unwrap([])
+ use <- bool.guard(when: list.is_empty(rows), return: default)
+ list.fold(rows, default, next)
+ |> compute_rows(offset + 1000, db, _, next)
+}

apps/backend/src/backend/postgres/postgres.gleam

@@ -19,6 +19,7 @@ pub fn connect(cnf: Config) {
  hex_api_key: cnf.hex_api_key,
  github_token: cnf.github_token,
  env: cnf.env,
+ type_search_subject: option.None,
  )
  }
 }