Practikal.Base 0.1.1

Practikal.Base

Functional library which contains a useful set of functions for building small-size/mid-size web applications.

Goals

The library is built targeting some goals:

• provide essential functions for building modern web applications.
• 0 dependencies - 3rd party framework and library agnostic excepting Newtonsoft.Json.
• functions are written following functional programming principles (immutability - immutable states, purity - pure functions, composability - partial-applications, high-order functions).
• each module is completely independent and does not refer any other library module (excepting migrations).
• functions should be as simple as possible.
• FP on/off OOP.

Description

The library contains functions for:

• exceptions handling.
• serializing data.
• validating data.
• files handling.
• identities handling.
• migrations handling.

Install

dotnet add package Practikal.Base

Exceptions handling

Functions for:

• getting user message.
• getting technical message.

Simple logging calls:

open System
open Practikal

getUserMessage(new Exception('user:message'))  // output: message
getUserMessage(new Exception('message'))  // output: System failure.
getTechnicalMessage(new Exception('message'))  // output: message
getTechnicalMessage(new Exception('user:message'))  // output: user:message

Serialization

Functions for:

• serializing data.
• deserializing data;

open Practikal

    type Record = {
        Field1: string;
        Field2: int;
    }

    Some { Field1 = "abc"; Field2 = 123 }
    |> serialize 
    |> deserialize<Record>

    // output: Some { Field1 = "abc"; Field2 = 123; }

Validation

Functions for:

• validating data.

open Practikal
open System.ComponentModel.DataAnnotations

    type Validation = {
        [<Required>] Field1: string;
        [<Required>] Field2: string;
    }

    validate { Field1 = input1; Field2 = input2 }

    // output: Success { Field1 = input1; Field2 = input2; }

    validate { Field1 = null; Field2 = input2 }

    // output: Failure "user:The Field1 field is required."

Files

Functions for:

• reading files from folder.
• reading files from assembly (embedded files).
• finding folder files.
• finding embedded assembly files.

    open System.Reflection
    open System.IO
    open Practikal
    open Practikal.Files

    let pattern = "File\S*(1|2).txt""
    pattern |> findEmbeddedFiles (Assembly.GetExecutingAssembly())
    pattern |> findFolderFiles (Directory.GetCurrentDirectory())
    pattern |> readEmbeddedFiles (Assembly.GetExecutingAssembly())
    pattern |> readFolderFiles (Directory.GetCurrentDirectory())

Identity

Functions for:

• set current principal.
• get current principal.
• set user id, user name, full name, role, authentication type for principal.
• get user id, user name, full name, is in role, is authenticated for current principal.

open Practikal

    { UserId = 0; UserName = ""; FullName = ""; Role = ""; AuthenticationType = "" }
    |> setUserId 123
    |> setUserName "username"
    |> setFullName "fullname"
    |> setRole "role"
    |> setAuthenticationType "authtype"
    |> setCurrentPrincipal

    getUserId()  // output: 123
    getUserName()  // output: "username"
    getFullName()  // output: "fullname"
    isInRole "role"  // output: true
    isAuthenticated()  // output: true 

Migrations

Functions for:

• apply migrations from folder.
• apply migrations from assembly.
• ensure database.
• change connection string.

Implement a very basic Entity Framework Core migrations capabilities.

open Practikal
open Practikal.Migrations
open Practikal.Files

    // ensure database
    let execSqlFiles (files: ReadFile list) = Success true

    MigrationAssembly (Assembly.GetExecutingAssembly())
    |> ensureDatabase execSqlFiles <| "CreateDatabase.sql"
    |> ignore

    // apply migrations
    let execSql (content: string) = ignore()
    let noFilter x = true

    MigrationAssembly (Assembly.GetExecutingAssembly())
    |> applyMigrations execSql noFilter <| "Migration.*.sql"