Electric.Shapes.Api (electric v1.2.4)

@type options() :: [
  inspector: {module(), [term()]},
  pg_id: nil | binary(),
  registry: atom(),
  shape_cache: {module(), [term()]},
  stack_events_registry: atom(),
  stack_id: binary(),
  storage: {module(), [term()]},
  persistent_kv: term(),
  allow_shape_deletion: boolean(),
  feature_flags: [binary()],
  keepalive_interval: integer(),
  long_poll_timeout: integer(),
  sse_timeout: integer(),
  max_age: integer(),
  stack_ready_timeout: integer(),
  stale_age: integer(),
  send_cache_headers?: boolean(),
  encoder: atom(),
  max_concurrent_requests: map()
]

shape_opts()

@type shape_opts() :: [
  relation: {binary(), binary()},
  where: term(),
  columns: [binary()] | nil,
  params: %{optional(binary()) => binary()},
  autofill_pk_select?: boolean(),
  replica: term(),
  feature_flags: [binary()],
  storage: nil | Electric.Shapes.Shape.storage_config(),
  log_mode: term(),
  table: binary(),
  schema: binary(),
  namespace: binary()
]

t()

@type t() :: %Electric.Shapes.Api{
  allow_shape_deletion: term(),
  configured: term(),
  encoder: term(),
  feature_flags: term(),
  inspector: term(),
  keepalive_interval: term(),
  long_poll_timeout: term(),
  max_age: term(),
  max_concurrent_requests: term(),
  persistent_kv: term(),
  pg_id: term(),
  registry: term(),
  send_cache_headers?: term(),
  shape: term(),
  shape_cache: term(),
  sse_encoder: term(),
  sse_timeout: term(),
  stack_events_registry: term(),
  stack_id: term(),
  stack_ready_timeout: term(),
  stale_age: term(),
  storage: term()
}

Functions

configure(opts)

configure!(opts)

delete_shape(request)

@spec delete_shape(Electric.Shapes.Api.Request.t()) ::
  Electric.Shapes.Api.Response.t()

@spec delete_shape(Plug.Conn.t()) :: Plug.Conn.t()

delete_shape(conn, request)

encode_error_message(api, message)

@spec encode_error_message(t() | Electric.Shapes.Api.Request.t(), term()) :: Enum.t()

encode_message(request, message)

@spec encode_message(Electric.Shapes.Api.Request.t(), term()) :: Enum.t()

if_not_modified(conn, request)

options(conn)

@spec options(Plug.Conn.t()) :: Plug.Conn.t()

plug_opts(opts)

predefined_shape(api, shape_params)

@spec predefined_shape(t(), shape_opts()) :: {:ok, t()} | {:error, term()}

Create a version of the given configured Api instance that is specific to the given shape.

This allows you to provide a locked-down version of the API that ignores shape-definition parameters such as table, where and columns and only honours the shape-tailing parameters such as offset and handle.

schema(arg1)

serve_shape_log(request)

@spec serve_shape_log(Electric.Shapes.Api.Request.t()) ::
  Electric.Shapes.Api.Response.t()

Return shape log data.

serve_shape_log(conn, request)

serve_shape_response(request)

serve_shape_response(conn, request)

serve_subset_response(request)

stack_id(arg1)

@spec stack_id(
  t()
  | Electric.Shapes.Api.Request.t()
  | Electric.Shapes.Api.Response.t()
) :: String.t()

validate(api, params)

@spec validate(t(), %{required(atom() | binary()) => term()}) ::
  {:ok, Electric.Shapes.Api.Request.t()}
  | {:error, Electric.Shapes.Api.Response.t()}

Validate the parameters for the request.

validate_for_delete(api, params)

@spec validate_for_delete(t(), %{required(atom() | binary()) => term()}) ::
  {:ok, Electric.Shapes.Api.Request.t()}
  | {:error, Electric.Shapes.Api.Response.t()}