Image

head

code

root

para

L<Examples| file:../examples/index.podlite>


L<Download |file:../download/index.podlite>


React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


HEADER

FOOTER

README

JSON::Marshal - Make JSON from an Object.


=begin code
    use JSON::Marshal;

    class SomeClass {
      has Str $.string;
      has Int $.int;
      has Version $.version is marshalled-by('Str');
    }

    my $object = SomeClass.new(string => "string", int => 42, version => Version.new("0.0.1"));


    my Str $json = marshal($object); # -> "{ "string" : "string", "int" : 42, "version" : "0.0.1" }'

=end code


=begin code
    use JSON::Marshal;
    use JSON::OptIn;

    class SomeClass {
      has Str $.string is json;
      has Int $.int    is json;
      has Str $.secret;
      has Version $.version is marshalled-by('Str');
    }

    my $object = SomeClass.new(secret => "secret", string => "string", int => 42, version => Version.new("0.0.1"));


    my Str $json = marshal($object, :opt-in); # -> "{ "string" : "string", "int" : 42, "version" : "0.0.1" }'

=end code


This provides a single exported subroutine to create a JSON representation
of an object.  It should round trip back into an object of the same class
using L<JSON::Unmarshal|https://github.com/tadzik/JSON-Unmarshal>.


It only outputs the "public" attributes (that is those with accessors
created by declaring them with the '.' twigil. Attributes without acccessors
are ignored.


If you want to ignore any attributes without a value you can use the
:skip-null adverb to C<marshal>, which will supress the marshalling
of any undefined attributes.  Additionally if you want a finer-grained
control over this behaviour there is a 'json-skip-null' attribute trait
which will cause the specific attribute to be skipped if it isn't defined
irrespective of the C<skip-null>.  C<skip-null> or the C<json-skip-null>
trait is applied to a C<Positional> or C<Associative> attribute this
will suppress the marshalling of an empty list or object attribute.  If
you want to always explicitly suppress the marshalling of an attribute then
the the trait C<json-skip> on an attribute will prevent it being output
in the JSON.


By default B<all> public attributes will be candidates to be marshalled to JSON,
which may not be convenient for all applications (for example only a small
number of attributes should be marshalled in a large class,) so the C<marshal>
provides an C<:opt-in> adverb that inverts the behaviour so that only those
attributes which have one of the traits that control marshalling
(with the exception of C<json-skip>,) will be candidates.  The C<is json> trait
from L<JSON::OptIn|https://github.com/jonathanstowe/JSON-OptIn> can be supplied to
an attribute to mark it for marshalling explicitly, (it is implicit in all the
other traits bar C<json-skip>.)


To allow a finer degree of control of how an attribute is marshalled
an attribute trait C<is marshalled-by> is provided, this can take
either a Code object (an anonymous subroutine,) which should take as an
argument the value to be marshalled and should return a value that can be
completely represented as JSON, that is to say a string, number or boolean
or Nil or a Hash or Array who's values are those things. Alternatively
the name of a method that will be called on the value, the return value
being constrained as above. In the case of the Code argument to the
trait, the supplied subroutine should handle the case of an undefined
value for itself as appropriate, in the case of a method name it will
not be called at all and the attribute will be marshalled as Nil.


You can pass the adverb C<:sorted-keys> to C<marshal> which is in turn
passed on to C<JSON::Fast> to cause the keys to be sorted before the JSON
is created.


By default the JSON produced is I<pretty> (that is newlines and indentation,)
which is nice for humans to read but has a lot of superfluous characters in
it, this can be controlled by passing C<:!pretty> to C<marshal> which is passed
to C<JSON::Fast>



use JSON::OptIn;
use JSON::Name:ver<0.0.6+>;

module JSON::Marshal:ver<0.0.23>:auth<github:jonathanstowe> {

    use JSON::Fast:ver(v0.16+);


    role CustomMarshaller does JSON::OptIn::OptedInAttribute {
        method marshal($value, Mu:D $object) {
            ...
        }
    }

    role CustomMarshallerCode does CustomMarshaller {
        has &.marshaller is rw;

        method marshal($value, Mu:D $object) {
            # the dot below is important otherwise it refers
            # to the accessor method
            self.marshaller.($value);
        }
    }

    role CustomMarshallerMethod does CustomMarshaller {
        has Str $.marshaller is rw;
        method marshal($value, Mu:D $type) {
            my $meth = self.marshaller;
            $value.defined ?? $value."$meth"() !! Nil;
        }
    }

    multi sub trait_mod:<is> (Attribute $attr, :&marshalled-by!) is export {
        $attr does CustomMarshallerCode;
        $attr.marshaller = &marshalled-by;
    }

    multi sub trait_mod:<is> (Attribute $attr, Str:D :$marshalled-by!) is export {
        $attr does CustomMarshallerMethod;
        $attr.marshaller = $marshalled-by;
    }

    role SkipNull does JSON::OptIn::OptedInAttribute {
    }

    multi sub trait_mod:<is> (Attribute $attr, :$json-skip-null!) is export {
        $attr does SkipNull;
    }

    # This is a hard skip the attribute will never be emitted.
    role JsonSkip {
    }

    multi sub trait_mod:<is> (Attribute $attr, :$json-skip!) is export {
        $attr does JsonSkip;
    }



    multi sub _marshal(Cool $value, Bool :$skip-null, Bool :$opt-in ) {
        $value;
    }

    multi sub _marshal(Associative:U $, Bool :$skip-null, Bool :$opt-in  --> Nil ) {
        Nil;
    }
    multi sub _marshal(%obj, Bool :$skip-null, Bool :$opt-in  --> Hash ) {
        my %ret;

        for %obj.kv -> $key, $value {
            %ret{$key} = _marshal($value, :$skip-null, :$opt-in);
        }

        %ret;
    }

    multi sub _marshal(Positional:U $, Bool :$skip-null, Bool :$opt-in  --> Nil ) {
        Nil;
    }
    multi sub _marshal(@obj, Bool :$skip-null, Bool :$opt-in  --> Array) {
        my @ret;

        for @obj -> $item {
            @ret.push(_marshal($item, :$skip-null, :$opt-in));
        }
        @ret;
    }

    multi sub _marshal(Mu:U $, Bool :$skip-null, Bool :$opt-in  --> Nil ) {
        Nil;
    }

    multi sub _marshal(Mu:D $obj, Bool :$skip-null, Bool :$opt-in --> Hash ) {
        my %ret;
        my %local-attrs =  $obj.^attributes(:local).map({ $_.name => $_.package });
        for $obj.^attributes -> $attr {
            if %local-attrs{$attr.name}:exists && !(%local-attrs{$attr.name} === $attr.package ) {
                next;
            }
            if $attr.has_accessor {
                my $accessor-name = $attr.name.substr(2); # lose the sigil
                my $name = do if $attr ~~ JSON::Name::NamedAttribute {
                    $attr.json-name;
                }
                else {
                    $accessor-name;
                }
                my $value = $obj.^can($accessor-name) ?? $obj."$accessor-name"() !! $attr.get_value($obj);
                if serialise-ok($attr, $value, $skip-null, $opt-in) {
                    %ret{$name} = do if $attr ~~ CustomMarshaller {
                        $attr.marshal($value, $obj);
                    }
                    else {
                        _marshal($value, :$opt-in);
                    }
                }

            }
        }
        %ret;
    }

    sub serialise-ok(Attribute $attr, Mu $value, Bool $skip-null, Bool $opt-in --> Bool ) {
        my $rc = True;
        if  $attr ~~ JsonSkip || ( $opt-in && ( $attr !~~ JSON::OptIn::OptedInAttribute ) ) {
            $rc = False;
        }
        elsif $skip-null || ( $attr ~~ SkipNull ) {
            if $attr.type ~~ Associative|Positional {
                $rc = ?$value.elems;
            }
            else {
                $rc = $value.defined;
            }
        }
        $rc;
    }

    sub marshal(Any $obj, Bool :$skip-null, Bool :$sorted-keys = False, Bool :$pretty = True, Bool :$opt-in = False --> Str ) is export {
        my $ret = _marshal($obj, :$skip-null, :$opt-in);
        to-json($ret, :$sorted-keys, :$pretty);
    }
}
# vim: expandtab shiftwidth=4 ft=raku


Marshal

use JSON::Fast;
use MIME::Base64;
use OpenSSL::Digest;
use OpenSSL::RSATools;
use Digest::HMAC;

unit class JSON::JWT:ver<1.1>:auth<zef:raku-community-modules>;

multi method decode($jwt, :$alg where 'none') {
    my %pack := self!unpack($jwt);
    %pack<header><alg> ne 'none'
      ?? (die "Header lists signature type != 'none' (%pack<header><alg>)")
      !! %pack<signature>
        ?? (die "Signature exists with signature type = 'none'")
        !! %pack<body>
}
multi method decode($jwt, :$alg where 'HS256', :$secret!) {
    my %pack := self!unpack($jwt);
    %pack<header><alg> ne 'HS256'
      ?? (die "Header lists signature type != 'HS256' (%pack<header><alg>)")
      !! %pack<signature>
        # XXX secure compare? XXX #
        ?? hmac($secret, %pack<sigblob>, &sha256) eq %pack<signature>
          ?? %pack<body>
          !! (die "Signature does not match.")
        !! (die "No signature found.")
}
multi method decode($jwt, :$alg where 'RS256', :$pem!) {
    my %pack := self!unpack($jwt);
    %pack<header><alg> ne 'RS256'
      ?? (die "Header lists signature type != 'RS256' ("~%pack<header><alg>~")")
      !! %pack<signature>
        ?? OpenSSL::RSAKey.new(:public-pem($pem))
             .verify(%pack<sigblob>, %pack<signature>, :sha256)
          ?? %pack<body>
          !! (die "Signature verify failed.")
        !! (die "No signature found.")
}

method decode-noverify($jwt) { self!unpack($jwt)<body> }

method !unpack(Str:D $jwt) {
    my @parts = $jwt.split('.');
    die "JWT does not have 2 or 3 parts; cannot unpack."
      unless @parts == 2 | 3;

    my %pack;
    # MIME::Base64 doesn't do base64url
    my $part1 := @parts[0].trans: '-_' => '+/';
    my $part2 := @parts[1].trans: '-_' => '+/';

    %pack<header> := from-json MIME::Base64.decode-str: $part1;
    die "Not a JWT" if %pack<header><typ> ne 'JWT';

    %pack<body> := from-json MIME::Base64.decode-str: $part2;

    if @parts[2] -> $part3 {
        %pack<signature> :=
          MIME::Base64.decode: $part3.trans: '-_' => '+/';
    }
    %pack<sigblob> := "$part1.$part2".encode: 'ascii';

    %pack
}

multi method encode($data, :$alg where 'none' --> Str:D) {
    self!pack: %(body => $data, header => %(:typ<JWT>, :alg<none>));
}

multi method encode($data, :$alg where 'HS256', :$secret! --> Str:D) {
    my %pack = body => $data, header => %(:typ<JWT>, :alg<HS256>);
    my $sigstring := self!pack: %pack, :signing;
    %pack<signature> = hmac($secret, $sigstring.encode('ascii'), &sha256);

    self!pack(%pack)
}

multi method encode($data, :$alg where 'RS256', :$pem! --> Str:D) {
    my %pack = body => $data, header => %(:typ<JWT>, :alg<RS256>);
    my $sigstring := self!pack: %pack, :signing;
    my $key = OpenSSL::RSAKey.new: :private-pem($pem);
    %pack<signature> = $key.sign: $sigstring.encode('ascii'), :sha256;

    self!pack(%pack)
}

method !pack(%pack, :$signing --> Str:D) {
    my $packed :=
      MIME::Base64.encode-str(to-json(%pack<header>), :oneline)
        .trans('+/' => '-_').subst('=', :g)
      ~ "."
      ~ MIME::Base64.encode-str(to-json(%pack<body>), :oneline)
        .trans('+/' => '-_').subst('=', :g);

    %pack<signature>
      ?? $packed
           ~ "."
           ~ MIME::Base64.encode(%pack<signature>, :oneline)
              .trans('+/' => '-_').subst('=', :g)
      !! $packed
}



JSON::JWT - JSON Web Token (JWT) implementation for Raku


=begin code :lang<raku>

use JSON::JWT;

my $jwt = encode($data, :alg<none>);             # no encryption
my $jwt = encode($data, :alg<HS256>, :$secret);  # HS256 encryption
my $jwt = encode($data, :alg<RS256>, :$pem);     # RS256 encryption

my $data = decode($jwt, :alg<none>);             # no encryption
my $data = decode($jwt, :alg<HS256>, :$secret);  # HS256 encryption
my $data = decode($jwt, :alg<RS256>, :$pem);     # RS256 encryption

=end code


JSON::JWT provides a class with an implementation of the
JSON Web Token (JWT) standard, with support for C<HS256> and
C<RS256> encryption, or no encryption..


Source can be located at: https://github.com/raku-community-modules/JSON-JWT .
Comments and Pull Requests are welcome.


All files in this repository are licensed under the terms of Create Commons
License; for details please see the LICENSE file


The Raku Knowledge Base


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


README

NAME

SYNOPSIS

DESCRIPTION

AUTHOR

COPYRIGHT AND LICENSE

JSON::JWT v1.1

Authors

License

Dependencies

Test Dependencies

Provides

Documentation