package eliom

You can search for identifiers within the package.

in-package search v0.2.0

Advanced client/server Web and mobile framework

Install

dune-project

Dependency

ocsigen.org Readme Edit opam file Versions (33)

Authors

D

dev@ocsigen.org

Maintainers

D

dev@ocsigen.org

Sources

md5=a989128ffd2ffd4a74b17233cd0a4b46

sha512=ee76f43609fc33aad96758e9a9698ec517aa92eaaf4575e3e4b43aaa34b3659f0403370d1c8a20c605465802375cbdf7f98a0d086cb3c73e86d19115064f7f15

doc/eliom.server/Eliom_service_base/index.html

Module `Eliom_service_base`Source

Sourceval __eliom__compilation_unit_id__8wyVC6 : string

Sourcemodule Types : Eliom_service_sigs.TYPES

include module type of struct include Types end

type get = Types.get =

| Get_method

type put = Types.put =

| Put_method

type post = Types.post =

| Post_method

type delete = Types.delete =

| Delete_method

type co = Types.co =

| Co

type non_co = Types.non_co =

| Non_co

type ext = Types.ext =

| Ext

type non_ext = Types.non_ext =

| Non_ext

type http = Types.http =

| Http_ret

type 'a ocaml = 'a Types.ocaml =

| Ocaml of 'a

type non_ocaml = Types.non_ocaml =

| Non_ocaml

type reg = Types.reg =

| Reg

type non_reg = Types.non_reg =

| Non_reg

type ('get, 'tipo, 'gn) params = ('get, 'tipo, 'gn) Eliom_parameter.params_type constraint 'tipo = [< `WithSuffix | `WithoutSuffix ]

Method specification

type ('m, _, _, _, _, _, _) meth = ('m, _, _, _, _, _, _) Types.meth =

| Get : ('gp, 'tipo, 'gn) params -> (get, 'gp, 'gn, unit, unit, 'tipo, unit) meth
| Post : ('gp, 'tipo, 'gn) params * ('pp, [ `WithoutSuffix ], 'pn) params -> (post, 'gp, 'gn, 'pp, 'pn, 'tipo, 'gp) meth
| Put : ('gp, 'tipo, 'gn) params -> (put, 'gp, 'gn, Eliom_parameter.raw_post_data, Eliom_parameter.no_param_name, 'tipo, unit) meth
| Delete : ('gp, 'tipo, 'gn) params -> (delete, 'gp, 'gn, Eliom_parameter.raw_post_data, Eliom_parameter.no_param_name, 'tipo, unit) meth

Method specification datatype

An Eliom service (see Eliom_service_sigs.S.t) can respond to one of the following HTTP methods:

GET (Get g)
POST (Post (g, p))
PUT (Put g)
DELETE (Delete g)

In all cases, the service parameters need to be provided (see Eliom_parameter_sigs.S). POST (Post (g, p)) services accept both GET (g) and POST (p) parameters. For the other methods, only GET (g) parameters apply.

The type parameters are used to impose various type constraints, and are not necessarily of interest to the programmer. Their technical meaning is as follows.

0-th param : method
params 1-4 : GET and POST parameter types and names
param 5 : suffix parameters permitted or not
param 6 : non-unit only for the Post (g, p) case when g is not unit ; used to force unit GET parameters when needed

type 'm which_meth = 'm Types.which_meth =

| Get' : get which_meth
| Post' : post which_meth
| Put' : put which_meth
| Delete' : delete which_meth

Like meth but without the parameters

module Url = Eliom_lib.Url

Sourcetype suff = [

| `WithSuffix
| `WithoutSuffix

]

val params_of_meth : 
  'm 'gp 'gn 'pp 'pn 'x. ('m,
                           'gp,
                           'gn,
                           'pp,
                           'pn,
                           [< `WithSuffix | `WithoutSuffix ] as 'a,
                           'x)
                           meth ->
  ('gp, 'a, 'gn) params * ('pp, [ `WithoutSuffix ], 'pn) params

val which_meth_internal : 
  'm 'gp 'gn 'pp 'pn 'tipo 'x. ('m, 'gp, 'gn, 'pp, 'pn, 'tipo, 'x) meth ->
  'm which_meth

val is_post : 
  'm 'gp 'gn 'pp 'pn 'x. ('m,
                           'gp,
                           'gn,
                           'pp,
                           'pn,
                           [< `WithSuffix | `WithoutSuffix ],
                           'x)
                           meth ->
  bool

Sourceval is_post' : 'm. 'm which_meth -> bool

Sourcetype reload_fun =

| Rf_keep
| Rf_client_fun

Sourcetype att = {

prefix : string;
subpath : Url.path;
fullpath : Url.path;
get_name : Eliom_common.att_key_serv;
post_name : Eliom_common.att_key_serv;
redirect_suffix : bool;
priority : int;

}

Sourcetype non_att = {

na_name : Eliom_common.na_key_serv;
keep_get_na_params : bool;

}

Sourcetype 'a attached_info =

| Attached : att -> att attached_info
| Nonattached : non_att -> non_att attached_info

Sourcetype send_appl_content =

| XNever
| XAlways
| XSame_appl of string * string option
(*
Whether the service is capable to send application content or not. (application content has type Eliom_service.eliom_appl_answer: content of the application container, or xhr redirection ...). A link towards a service with send_appl_content = XNever will always answer a regular http frame (this will stop the application if used in a regular link or form, but not with XHR). XAlways means "for all applications" (like redirections/actions). XSame_appl means "only for this application". If there is a client side application, and the service has XAlways or XSame_appl when it is the same application, then the link (or form or change_page) will expect application content.
*)

Sourcetype service_kind = [

| `Service
| `AttachedCoservice
| `NonattachedCoservice
| `External

]

type ('get, 'post, 'meth, 'attached, 'co, 'ext, 'reg, +'tipo, 'getnames, 'postnames, 'rt)
  t =
  {

pre_applied_parameters : (string * Eliommod_parameters.param) list Eliom_lib.String.Table.t * (string * Eliommod_parameters.param) list;
get_params_type : ('get, 'tipo, 'getnames) Eliom_parameter.params_type;
post_params_type : ('post, [ `WithoutSuffix ], 'postnames) Eliom_parameter.params_type;
max_use : int option;
timeout : float option;
meth : 'meth which_meth;
kind : service_kind;
info : 'attached attached_info;
https : bool;
keep_nl_params : [ `All | `Persistent | `None ];
mutable send_appl_content : send_appl_content;
mutable client_fun : ('get -> 'post -> result Lwt.t) option ref Eliom_client_value.t option;
mutable reload_fun : reload_fun;
service_mark : (unit, unit, 'meth, 'attached, 'co, 'ext, 'reg, suff, unit, unit, unit) t Eliom_common.wrapper;

} constraint 'tipo = [< suff ]

Sourceand result =

| No_contents
| Dom of Js_of_ocaml.Dom_html.element Js_of_ocaml.Js.t
| Redirect : (unit, unit, get, _, _, _, _, [ `WithoutSuffix ], unit, unit, non_ocaml) t -> result
| Reload_action of {
1. hidden : bool;
2. https : bool;
}

val pre_wrap : 
  ('a, 'b, 'c, 'd, 'e, 'f, 'g, [< suff ] as 'h, 'i, 'j, 'k) t ->
  ('a, 'b, 'c, 'd, 'l, 'm, 'n, 'h, 'i, 'j, 'o) t

type unit_service =
  (unit,
    unit,
    get,
    att,
    non_co,
    non_ext,
    non_reg,
    [ `WithoutSuffix ],
    unit,
    unit,
    non_ocaml)
    t

val service_mark : 
  unit ->
  ('a, 'b, 'c, 'd, 'e, 'f, 'g, [< suff ], 'h, 'i, 'j) t Eliom_common.wrapper

val info : 
  ('a, 'b, 'c, 'd, 'e, 'f, 'g, [< suff ], 'h, 'i, 'j) t ->
  'd attached_info

val pre_applied_parameters : 
  ('a, 'b, 'c, 'd, 'e, 'f, 'g, [< suff ], 'h, 'i, 'j) t ->
  (string * Eliommod_parameters.param) list Eliom_lib.String.Table.t
  * (string * Eliommod_parameters.param) list

val get_params_type : 
  ('a, 'b, 'c, 'd, 'e, 'f, 'g, [< suff ] as 'h, 'i, 'j, 'k) t ->
  ('a, 'h, 'i) Eliom_parameter.params_type

val post_params_type : 
  ('a, 'b, 'c, 'd, 'e, 'f, 'g, [< suff ], 'h, 'i, 'j) t ->
  ('b, [ `WithoutSuffix ], 'i) Eliom_parameter.params_type

Sourceval prefix : att -> string

Sourceval sub_path : att -> Url.path

Sourceval redirect_suffix : att -> bool

Sourceval full_path : att -> Url.path

Sourceval get_name : att -> Eliom_common.att_key_serv

Sourceval post_name : att -> Eliom_common.att_key_serv

Sourceval na_name : non_att -> Eliom_common.na_key_serv

Sourceval na_keep_get_na_params : non_att -> bool

val max_use : 
  ('a, 'b, 'c, 'd, 'e, 'f, 'g, [< suff ], 'h, 'i, 'j) t ->
  int option

val timeout : 
  ('a, 'b, 'c, 'd, 'e, 'f, 'g, [< suff ], 'h, 'i, 'j) t ->
  float option

Sourceval https : ('a, 'b, 'c, 'd, 'e, 'f, 'g, [< suff ], 'h, 'i, 'j) t -> bool

Sourceval priority : att -> int

val internal_set_client_fun : 
  service:('a, 'b, 'c, 'd, 'e, 'f, 'g, [< suff ], 'h, 'i, 'j) t ->
  ('get -> 'post -> result Lwt.t) Eliom_client_value.t ->
  unit

Sourceval is_external : ('a, 'b, 'c, 'd, 'e, 'f, 'g, [< suff ], 'h, 'i, 'j) t -> bool

Sourceval default_priority : int

val meth : 
  ('a, 'b, 'c, 'd, 'e, 'f, 'g, [< suff ], 'h, 'i, 'j) t ->
  'c which_meth

val change_get_num : 
  ('a, 'b, 'c, 'd, 'e, 'f, 'g, [< suff ] as 'h, 'i, 'j, 'k) t ->
  att ->
  Eliom_common.att_key_serv ->
  ('a, 'b, 'c, att, 'l, 'm, 'n, 'h, 'i, 'j, 'o) t

val static_dir_ : 
  ?https:bool ->
  unit ->
  (string list,
    unit,
    get,
    att,
    'a,
    'b,
    'c,
    [ `WithSuffix ],
    [ `One of string list ] Eliom_parameter.param_name,
    unit,
    'd)
    t

Static directories *

val static_dir : 
  unit ->
  (string list,
    unit,
    get,
    att,
    'a,
    'b,
    'c,
    [ `WithSuffix ],
    [ `One of string list ] Eliom_parameter.param_name,
    unit,
    'd)
    t

val https_static_dir : 
  unit ->
  (string list,
    unit,
    get,
    att,
    'a,
    'b,
    'c,
    [ `WithSuffix ],
    [ `One of string list ] Eliom_parameter.param_name,
    unit,
    'd)
    t

val get_static_dir_ : 
  ?https:bool ->
  ?keep_nl_params:[ `All | `None | `Persistent ] ->
  get_params:('a, [ `WithoutSuffix ], 'b) Eliom_parameter.params_type ->
  unit ->
  (string list * 'a,
    unit,
    get,
    att,
    'c,
    'd,
    'e,
    [ `WithSuffix ],
    [ `One of string list ] Eliom_parameter.param_name * 'b,
    unit,
    'f)
    t

val static_dir_with_params : 
  ?keep_nl_params:[ `All | `None | `Persistent ] ->
  get_params:('a, [ `WithoutSuffix ], 'b) Eliom_parameter.params_type ->
  unit ->
  (string list * 'a,
    unit,
    get,
    att,
    'c,
    'd,
    'e,
    [ `WithSuffix ],
    [ `One of string list ] Eliom_parameter.param_name * 'b,
    unit,
    'f)
    t

val https_static_dir_with_params : 
  ?keep_nl_params:[ `All | `None | `Persistent ] ->
  get_params:('a, [ `WithoutSuffix ], 'b) Eliom_parameter.params_type ->
  unit ->
  (string list * 'a,
    unit,
    get,
    att,
    'c,
    'd,
    'e,
    [ `WithSuffix ],
    [ `One of string list ] Eliom_parameter.param_name * 'b,
    unit,
    'f)
    t

val send_appl_content : 
  ('a, 'b, 'c, 'd, 'e, 'f, 'g, [< suff ], 'h, 'i, 'j) t ->
  send_appl_content

val set_send_appl_content : 
  ('a, 'b, 'c, 'd, 'e, 'f, 'g, [< suff ], 'h, 'i, 'j) t ->
  send_appl_content ->
  unit

Sourceval append_suffix : 'a list -> 'a list -> 'a list

val preapply : 
  service:('a, 'b, 'c, att, 'd, 'e, 'f, [< suff ], 'g, 'h, 'i) t ->
  'a ->
  (unit, 'b, 'c, att, 'j, 'k, 'l, [ `WithoutSuffix ], unit, 'h, 'm) t

val reload_action_aux : 
  bool ->
  (unit, unit, get, non_att, 'a, 'b, 'c, [ `WithoutSuffix ], unit, unit, 'd) t

val reload_action : 
  (unit, unit, get, non_att, 'a, 'b, 'c, [ `WithoutSuffix ], unit, unit, 'd) t

val reload_action_https : 
  (unit, unit, get, non_att, 'a, 'b, 'c, [ `WithoutSuffix ], unit, unit, 'd) t

val reload_action_hidden_aux : 
  bool ->
  (unit, unit, get, non_att, 'a, 'b, 'c, [ `WithoutSuffix ], unit, unit, 'd) t

val reload_action_hidden : 
  (unit, unit, get, non_att, 'a, 'b, 'c, [ `WithoutSuffix ], unit, unit, 'd) t

val reload_action_https_hidden : 
  (unit, unit, get, non_att, 'a, 'b, 'c, [ `WithoutSuffix ], unit, unit, 'd) t

val add_non_localized_get_parameters : 
  params:('a, [ `WithoutSuffix ], 'b) Eliom_parameter.non_localized_params ->
  service:('c, 'd, 'e, 'f, 'g, 'h, 'i, [< suff ] as 'j, 'k, 'l, 'm) t ->
  ('c * 'a, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k * 'b, 'l, 'n) t

val add_non_localized_post_parameters : 
  params:('a, [ `WithoutSuffix ], 'b) Eliom_parameter.non_localized_params ->
  service:('c, 'd, 'e, 'f, 'g, 'h, 'i, [< suff ] as 'j, 'k, 'l, 'm) t ->
  ('c, 'd * 'a, 'e, 'f, 'g, 'h, 'i, 'j, 'k, 'l * 'b, 'n) t

val keep_nl_params : 
  ('a, 'b, 'c, 'd, 'e, 'f, 'g, [< suff ], 'h, 'i, 'j) t ->
  [ `All | `None | `Persistent ]

val untype : 
  ('get,
    'post,
    'meth,
    'attached,
    'co,
    'ext,
    'tipo,
    [< suff ] as 'a,
    'postnames,
    'register,
    'b)
    t ->
  ('get,
    'post,
    'meth,
    'attached,
    'co,
    'ext,
    'tipo,
    'a,
    'postnames,
    'register,
    'c)
    t

Sourcetype (_, _, _) path_option =

| Path : Eliom_lib.Url.path -> (att, non_co, _) path_option
| No_path : (non_att, co, unit) path_option

Sourceval eliom_appl_answer_content_type : string

Sourceval uniqueid : unit -> int

Sourceval new_state : unit -> string

val default_csrf_scope : 
  [< Eliom_common.user_scope ] option ->
  Eliom_common.user_scope

Sourceexception Unreachable_exn

val attached_info : 
  ('a, 'b, 'c, att, 'd, 'e, 'f, [< suff ], 'g, 'h, 'i) t ->
  att

val non_attached_info : 
  ('a, 'b, 'c, non_att, 'd, 'e, 'f, [< suff ], 'g, 'h, 'i) t ->
  non_att

Sourceval no_client_fun : unit -> 'a ref Eliom_client_value.t option

val main_service : 
  https:bool ->
  prefix:string ->
  path:Url.path ->
  site_dir:string list ->
  kind:service_kind ->
  meth:'a which_meth ->
  ?redirect_suffix:bool ->
  ?keep_nl_params:[ `All | `None | `Persistent ] ->
  ?priority:int ->
  get_params:('b, [< suff ] as 'c, 'd) Eliom_parameter.params_type ->
  post_params:('e, [ `WithoutSuffix ], 'f) Eliom_parameter.params_type ->
  reload_fun:reload_fun ->
  unit ->
  ('b, 'e, 'a, att, 'g, 'h, 'i, 'c, 'd, 'f, 'j) t

Create a main service (not a coservice), internal or external

val extern : 
  ?keep_nl_params:[ `All | `None | `Persistent ] ->
  prefix:string ->
  path:Url.path ->
  meth:('a, 'b, 'c, 'd, 'e, [< suff ] as 'f, 'g) meth ->
  unit ->
  ('b, 'd, 'a, att, 'h, 'i, 'j, 'f, 'c, 'e, 'k) t

val which_meth : 
  ('a, 'b, 'c, 'd, 'e, 'f, 'g, [< suff ], 'h, 'i, 'j) t ->
  'c which_meth

val which_meth_untyped : 
  ('a, 'b, 'm, 'c, 'd, 'e, 'f, [< suff ], 'g, 'h, 'i) t ->
  [> `Delete | `Get | `Post | `Put ]