@pgpm/base32 0.4.0

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Dan Lynch <pyramation@gmail.com>
+Copyright (c) 2025 Interweb, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/Makefile

@@ -0,0 +1,6 @@
+EXTENSION = launchql-base32
+DATA = sql/launchql-base32--0.4.6.sql
+
+PG_CONFIG = pg_config
+PGXS := $(shell $(PG_CONFIG) --pgxs)
+include $(PGXS)

package/README.md

@@ -0,0 +1,91 @@
+# @pgpm/base32
+
+RFC4648 Base32 encode/decode in plpgsql
+
+# Usage
+
+```sql
+select base32.encode('foo');
+-- MZXW6===
+
+
+select base32.decode('MZXW6===');
+-- foo
+```
+
+# credits
+
+Thanks to 
+
+https://tools.ietf.org/html/rfc4648
+
+https://www.youtube.com/watch?v=Va8FLD-iuTg
+
+# Development
+
+## start the postgres db process
+
+First you'll want to start the postgres docker (you can also just use `docker-compose up -d`):
+
+```sh
+make up
+```
+
+## install modules
+
+Install modules
+
+```sh
+yarn install
+```
+
+## install the Postgres extensions
+
+Now that the postgres process is running, install the extensions:
+
+```sh
+make install
+```
+
+This basically `ssh`s into the postgres instance with the `packages/` folder mounted as a volume, and installs the bundled sql code as pgxn extensions.
+
+## testing
+
+Testing will load all your latest sql changes and create fresh, populated databases for each sqitch module in `packages/`.
+
+```sh
+yarn test:watch
+```
+
+## building new modules
+
+Create a new folder in `packages/`
+
+```sh
+lql init
+```
+
+Then, run a generator:
+
+```sh
+lql generate
+```
+
+You can also add arguments if you already know what you want to do:
+
+```sh
+lql generate schema --schema myschema
+lql generate table --schema myschema --table mytable
+```
+
+## deploy code as extensions
+
+`cd` into `packages/<module>`, and run `lql package`. This will make an sql file in `packages/<module>/sql/` used for `CREATE EXTENSION` calls to install your sqitch module as an extension.
+
+## recursive deploy
+
+You can also deploy all modules utilizing versioning as sqtich modules. Remove `--createdb` if you already created your db:
+
+```sh
+lql deploy awesome-db --yes --recursive --createdb
+```

package/__tests__/__snapshots__/base32.decode.test.ts.snap

@@ -0,0 +1,21 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`base32.decode cases INQXI 1`] = `"Cat"`;
+
+exports[`base32.decode cases MNUGK3LJON2HE6LJONTXEZLBOQ====== 1`] = `"chemistryisgreat"`;
+
+exports[`base32.decode cases MY====== 1`] = `"f"`;
+
+exports[`base32.decode cases MZXQ==== 1`] = `"fo"`;
+
+exports[`base32.decode cases MZXW6=== 1`] = `"foo"`;
+
+exports[`base32.decode cases MZXW6YQ= 1`] = `"foob"`;
+
+exports[`base32.decode cases MZXW6YTB 1`] = `"fooba"`;
+
+exports[`base32.decode cases MZXW6YTBOI====== 1`] = `"foobar"`;
+
+exports[`base32.decode cases case: 1 1`] = `""`;
+
+exports[`base32.decode cases mzxw6ytb 1`] = `"fooba"`;

package/__tests__/__snapshots__/base32.encode.test.ts.snap

@@ -0,0 +1,15 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`base32.encode case: 1 1`] = `""`;
+
+exports[`base32.encode f 1`] = `"MY======"`;
+
+exports[`base32.encode fo 1`] = `"MZXQ===="`;
+
+exports[`base32.encode foo 1`] = `"MZXW6==="`;
+
+exports[`base32.encode foob 1`] = `"MZXW6YQ="`;
+
+exports[`base32.encode fooba 1`] = `"MZXW6YTB"`;
+
+exports[`base32.encode foobar 1`] = `"MZXW6YTBOI======"`;

package/__tests__/base32.decode.test.ts

@@ -0,0 +1,95 @@
+import { getConnections, PgTestClient } from 'pgsql-test';
+import cases from 'jest-in-case';
+
+let pg: PgTestClient;
+let teardown:  () => Promise<void>;
+
+beforeAll(async () => {
+  ({ pg, teardown } = await getConnections());
+});
+
+afterAll(async () => {
+  await teardown();
+});
+
+
+it('base32_to_decimal', async () => {
+    const { base32_to_decimal } = await pg.one(
+    `SELECT base32.base32_to_decimal($1::text) AS base32_to_decimal`,
+    ['INQXI===']
+  );
+  expect(base32_to_decimal).toEqual(['8', '13', '16', '23', '8', '=', '=', '=']);
+});
+
+it('decimal_to_chunks', async () => {
+    const { decimal_to_chunks } = await pg.one(
+    `SELECT base32.decimal_to_chunks($1::text[]) AS decimal_to_chunks`,
+    [['8', '13', '16', '23', '8', '=', '=', '=']]
+  );
+  expect(decimal_to_chunks).toEqual([
+    '01000',
+    '01101',
+    '10000',
+    '10111',
+    '01000',
+    'xxxxx',
+    'xxxxx',
+    'xxxxx'
+  ]);
+});
+
+it('decode', async () => {
+    const { decode } = await pg.one(
+    `SELECT base32.decode($1::text) AS decode`,
+    ['INQXI']
+  );
+  expect(decode).toEqual('Cat');
+});
+
+it('zero_fill', async () => {
+    const { zero_fill } = await pg.one(
+    `SELECT base32.zero_fill($1::int, $2::int) AS zero_fill`,
+    [300, 2]
+  );
+  expect(zero_fill).toBe('75');
+});
+
+it('zero_fill (-)', async () => {
+    const { zero_fill } = await pg.one(
+    `SELECT base32.zero_fill($1::int, $2::int) AS zero_fill`,
+    [-300, 2]
+  );
+  expect(zero_fill).toBe('1073741749');
+});
+
+it('zero_fill (0)', async () => {
+    const { zero_fill } = await pg.one(
+    `SELECT base32.zero_fill($1::int, $2::int) AS zero_fill`,
+    [-300, 0]
+  );
+  expect(zero_fill).toBe('4294966996');
+});
+
+cases(
+  'base32.decode cases',
+  async (opts: { name: string; result: string }) => {
+        const { decode } = await pg.one(
+      `SELECT base32.decode($1::text) AS decode`,
+      [opts.name]
+    );
+    expect(decode).toEqual(opts.result);
+    expect(decode).toMatchSnapshot();
+  },
+  [
+    { result: '', name: '' },
+    { result: 'Cat', name: 'INQXI' },
+    { result: 'chemistryisgreat', name: 'MNUGK3LJON2HE6LJONTXEZLBOQ======' },
+    { result: 'f', name: 'MY======' },
+    { result: 'fo', name: 'MZXQ====' },
+    { result: 'foo', name: 'MZXW6===' },
+    { result: 'foob', name: 'MZXW6YQ=' },
+    { result: 'fooba', name: 'MZXW6YTB' },
+    { result: 'fooba', name: 'mzxw6ytb' },
+    { result: 'foobar', name: 'MZXW6YTBOI======' }
+  ]
+);

package/__tests__/base32.encode.test.ts

@@ -0,0 +1,137 @@
+import { getConnections, PgTestClient } from 'pgsql-test';
+import cases from 'jest-in-case';
+
+let pg: PgTestClient;
+let teardown:  () => Promise<void>;
+
+beforeAll(async () => {
+  ({ pg, teardown } = await getConnections());
+});
+
+afterAll(async () => {
+  await teardown();
+});
+
+
+it('to_ascii', async () => {
+  const { to_ascii } = await pg.one(
+    `SELECT base32.to_ascii($1::text) AS to_ascii`,
+    ['Cat']
+  );
+  expect(to_ascii).toEqual([67, 97, 116]);
+});
+
+it('to_binary', async () => {
+  const { to_ascii } = await pg.one(
+    `SELECT base32.to_ascii($1::text) AS to_ascii`,
+    ['Cat']
+  );
+  const { to_binary } = await pg.one(
+    `SELECT base32.to_binary($1::int[]) AS to_binary`,
+    [to_ascii]
+  );
+  expect(to_binary).toEqual(['01000011', '01100001', '01110100']);
+});
+
+it('to_groups', async () => {
+  const { to_groups } = await pg.one(
+    `SELECT base32.to_groups($1::text[]) AS to_groups`,
+    [['01000011', '01100001', '01110100']]
+  );
+  expect(to_groups).toEqual([
+    '01000011',
+    '01100001',
+    '01110100',
+    'xxxxxxxx',
+    'xxxxxxxx'
+  ]);
+});
+
+it('to_chunks', async () => {
+  const { to_chunks } = await pg.one(
+    `SELECT base32.to_chunks($1::text[]) AS to_chunks`,
+    [['01000011', '01100001', '01110100', 'xxxxxxxx', 'xxxxxxxx']]
+  );
+  expect(to_chunks).toEqual([
+    '01000',
+    '01101',
+    '10000',
+    '10111',
+    '0100x',
+    'xxxxx',
+    'xxxxx',
+    'xxxxx'
+  ]);
+});
+
+it('fill_chunks', async () => {
+  const { fill_chunks } = await pg.one(
+    `SELECT base32.fill_chunks($1::text[]) AS fill_chunks`,
+    [[
+      '01000',
+      '01101',
+      '10000',
+      '10111',
+      '0100x',
+      'xxxxx',
+      'xxxxx',
+      'xxxxx'
+    ]]
+  );
+  expect(fill_chunks).toEqual([
+    '01000',
+    '01101',
+    '10000',
+    '10111',
+    '01000',
+    'xxxxx',
+    'xxxxx',
+    'xxxxx'
+  ]);
+});
+
+it('to_decimal', async () => {
+  const { to_decimal } = await pg.one(
+    `SELECT base32.to_decimal($1::text[]) AS to_decimal`,
+    [[
+      '01000',
+      '01101',
+      '10000',
+      '10111',
+      '01000',
+      'xxxxx',
+      'xxxxx',
+      'xxxxx'
+    ]]
+  );
+  expect(to_decimal).toEqual(['8', '13', '16', '23', '8', '=', '=', '=']);
+});
+
+it('to_base32', async () => {
+  const { to_base32 } = await pg.one(
+    `SELECT base32.to_base32($1::text[]) AS to_base32`,
+    [['8', '13', '16', '23', '8', '=', '=', '=']]
+  );
+  expect(to_base32).toEqual('INQXI===');
+});
+
+cases(
+  'base32.encode',
+  async (opts: { name: string; result: string }) => {
+      const { encode } = await pg.one(
+      `SELECT base32.encode($1::text) AS encode`,
+      [opts.name]
+    );
+    expect(encode).toEqual(opts.result);
+    expect(encode).toMatchSnapshot();
+  },
+  [
+    { name: '', result: '' },
+    { name: 'f', result: 'MY======' },
+    { name: 'fo', result: 'MZXQ====' },
+    { name: 'foo', result: 'MZXW6===' },
+    { name: 'foob', result: 'MZXW6YQ=' },
+    { name: 'fooba', result: 'MZXW6YTB' },
+    { name: 'foobar', result: 'MZXW6YTBOI======' }
+  ]
+);

package/deploy/schemas/base32/procedures/decode.sql

@@ -0,0 +1,178 @@
+-- Deploy schemas/base32/procedures/decode to pg
+
+-- requires: schemas/base32/schema
+-- requires: schemas/base32/procedures/encode 
+
+BEGIN;
+
+-- 'I' => '8'
+CREATE FUNCTION base32.base32_alphabet_to_decimal(
+  input text
+) returns text as $$
+DECLARE
+  alphabet text = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
+  alpha int;
+BEGIN
+  alpha = position(input in alphabet) - 1;
+  IF (alpha < 0) THEN 
+    RETURN '=';
+  END IF;
+  RETURN alpha::text;
+END;
+$$
+LANGUAGE 'plpgsql' IMMUTABLE;
+
+-- INQXI===  =>  ['8', '13', '16', '23', '8', '=', '=', '=']
+CREATE FUNCTION base32.base32_to_decimal(
+  input text 
+) returns text[] as $$
+DECLARE
+  i int;
+  output text[];
+BEGIN
+  input = upper(input);
+  FOR i IN 1 .. character_length(input) LOOP
+    output = array_append(output, base32.base32_alphabet_to_decimal(substring(input from i for 1)));
+  END LOOP;
+  RETURN output;
+END;
+$$
+LANGUAGE 'plpgsql' STABLE;
+
+-- ['8', '13', '16', '23', '8', '=', '=', '=']
+-- [ '01000', '01101', '10000', '10111', '01000', 'xxxxx', 'xxxxx', 'xxxxx' ]
+CREATE FUNCTION base32.decimal_to_chunks(
+  input text[]
+) returns text[] as $$
+DECLARE
+  i int;
+  part text;
+  output text[];
+BEGIN
+  FOR i IN 1 .. cardinality(input) LOOP
+    part = input[i];
+    IF (part = '=') THEN 
+      output = array_append(output, 'xxxxx');
+    ELSE
+      output = array_append(output, right(base32.to_binary(part::int), 5));
+    END IF;
+  END LOOP;
+  RETURN output;
+END;
+$$
+LANGUAGE 'plpgsql' STABLE;
+
+CREATE FUNCTION base32.base32_alphabet_to_decimal_int(
+  input text
+) returns int as $$
+DECLARE
+  alphabet text = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
+  alpha int;
+BEGIN
+  alpha = position(input in alphabet) - 1;
+  RETURN alpha;
+END;
+$$
+LANGUAGE 'plpgsql' IMMUTABLE;
+
+-- this emulates the >>> (unsigned right shift)
+-- https://stackoverflow.com/questions/41134337/unsigned-right-shift-zero-fill-right-shift-in-php-java-javascript-equiv
+CREATE FUNCTION base32.zero_fill(
+  a int, b int
+) returns bigint as $$
+DECLARE
+  bin text;
+  m int;
+BEGIN
+
+  IF (b >= 32 OR b < -32) THEN 
+    m = b/32;
+    b = b-(m*32);
+  END IF;
+
+  IF (b < 0) THEN
+    b = 32 + b;
+  END IF;
+
+  IF (b = 0) THEN
+      return ((a>>1)&2147483647)*2::bigint+((a>>b)&1);
+  END IF;
+
+  IF (a < 0) THEN
+    a = (a >> 1); 
+    a = a & 2147483647; -- 0x7fffffff
+    a = a | 1073741824; -- 0x40000000
+    a = (a >> (b - 1)); 
+  ELSE
+    a = (a >> b); 
+  END IF; 
+
+  RETURN a;
+END;
+$$
+LANGUAGE 'plpgsql' IMMUTABLE;
+
+CREATE FUNCTION base32.valid(
+  input text
+) returns boolean as $$
+BEGIN 
+  IF (upper(input) ~* '^[A-Z2-7]+=*$') THEN 
+    RETURN true;
+  END IF;
+  RETURN false;
+END;
+$$
+LANGUAGE 'plpgsql' IMMUTABLE;
+
+CREATE FUNCTION base32.decode(
+  input text
+) returns text as $$
+DECLARE
+  i int;
+  arr int[];
+  output text[];
+  len int;
+  num int;
+
+  value int = 0;
+  index int = 0;
+  bits int = 0;
+BEGIN
+  len = character_length(input);
+  IF (len = 0) THEN 
+    RETURN '';
+  END IF;
+
+  IF (NOT base32.valid(input)) THEN 
+    RAISE EXCEPTION 'INVALID_BASE32';
+  END IF;
+
+  input = replace(input, '=', '');
+  input = upper(input);
+  len = character_length(input);
+  num = len * 5 / 8;
+
+  select array(select * from generate_series(1,num))
+  INTO arr;
+  
+  FOR i IN 1 .. len LOOP
+    value = (value << 5) | base32.base32_alphabet_to_decimal_int(substring(input from i for 1));
+    bits = bits + 5;
+    IF (bits >= 8) THEN
+      arr[index] = base32.zero_fill(value, (bits - 8)) & 255; -- arr[index] = (value >>> (bits - 8)) & 255;
+      index = index + 1;
+      bits = bits - 8;
+    END IF;
+  END LOOP;
+
+  len = cardinality(arr);
+  FOR i IN 0 .. len-2 LOOP
+     output = array_append(output, chr(arr[i]));
+  END LOOP;
+
+  RETURN array_to_string(output, '');
+END;
+$$
+LANGUAGE 'plpgsql' STABLE;
+
+COMMIT;

package/deploy/schemas/base32/procedures/encode.sql

@@ -0,0 +1,266 @@
+-- Deploy schemas/base32/procedures/encode to pg
+
+-- requires: schemas/base32/schema
+
+-- https://tools.ietf.org/html/rfc4648
+-- https://www.youtube.com/watch?v=Va8FLD-iuTg
+
+BEGIN;
+
+ -- '01000011' => 67
+CREATE FUNCTION base32.binary_to_int(
+  input text
+) returns int as $$
+DECLARE
+  i int;
+  buf text;
+BEGIN
+    buf = 'SELECT B''' || input || '''::int';
+    EXECUTE buf INTO i;
+    RETURN i;
+END;
+$$
+LANGUAGE 'plpgsql' IMMUTABLE;
+
+ -- ASCII decimal values Cat => [67,97,116]
+CREATE FUNCTION base32.to_ascii(
+  input text
+) returns int[] as $$
+DECLARE
+  i int;
+  output int[];
+BEGIN
+  FOR i IN 1 .. character_length(input) LOOP
+    output = array_append(output, ascii(substring(input from i for 1)));
+  END LOOP;
+  RETURN output;
+END;
+$$
+LANGUAGE 'plpgsql' IMMUTABLE;
+
+-- 67 => '01000011'
+CREATE FUNCTION base32.to_binary(
+  input int
+) returns text as $$
+DECLARE
+  i int = 1;
+  j int = 0;
+  output char[] = ARRAY['x', 'x', 'x', 'x', 'x', 'x', 'x', 'x'];
+BEGIN
+  WHILE i < 256 LOOP 
+    output[8-j] = (CASE WHEN (input & i) > 0 THEN '1' ELSE '0' END)::char;
+    i = i << 1;
+    j = j + 1;
+  END LOOP;
+  RETURN array_to_string(output, '');
+END;
+$$
+LANGUAGE 'plpgsql' IMMUTABLE;
+
+-- [67,97,116] => [01000011, 01100001, 01110100]
+CREATE FUNCTION base32.to_binary(
+  input int[]
+) returns text[] as $$
+DECLARE
+  i int;
+  output text[];
+BEGIN
+  FOR i IN 1 .. cardinality(input) LOOP
+    output = array_append(output, base32.to_binary(input[i]));  
+  END LOOP;
+  RETURN output;
+END;
+$$
+LANGUAGE 'plpgsql' IMMUTABLE;
+
+  -- convert an input byte stream into group of 5 bytes
+  -- if there are less than 5, adding padding
+ 
+  -- [01000011, 01100001, 01110100, xxxxxxxx, xxxxxxxx]
+
+CREATE FUNCTION base32.to_groups(
+  input text[]
+) returns text[] as $$
+DECLARE
+  i int;
+  output text[];
+  len int = cardinality(input);
+BEGIN
+  IF ( len % 5 = 0 ) THEN 
+    RETURN input;
+  END IF;
+  FOR i IN 1 .. 5 - (len % 5) LOOP
+    input = array_append(input, 'xxxxxxxx');
+  END LOOP;
+  RETURN input;
+END;
+$$
+LANGUAGE 'plpgsql' IMMUTABLE;
+
+  -- break these into 5 bit chunks (5 * 8 = 40 bits, when we 40/5 = 8 new elements of 5 bits each)
+
+  -- [01000, 01101, 10000, 10111, 0100x, xxxxx, xxxxx, xxxxx]
+
+CREATE FUNCTION base32.string_nchars(text, integer)
+RETURNS text[] AS $$
+SELECT ARRAY(SELECT substring($1 from n for $2)
+  FROM generate_series(1, length($1), $2) n);
+$$ LANGUAGE sql IMMUTABLE;
+
+CREATE FUNCTION base32.to_chunks(
+  input text[]
+) returns text[] as $$
+DECLARE
+  i int;
+  output text[];
+  str text;
+  len int = cardinality(input);
+BEGIN
+  RETURN base32.string_nchars(array_to_string(input, ''), 5);
+END;
+$$
+LANGUAGE 'plpgsql' IMMUTABLE;
+
+  -- if a chunk has a mix of real bits (0|1) and empty (x), replace x with 0
+
+  -- [01000, 01101, 10000, 10111, 0100x, xxxxx, xxxxx, xxxxx]
+  -- [01000, 01101, 10000, 10111, 01000, xxxxx, xxxxx, xxxxx]
+
+CREATE FUNCTION base32.fill_chunks(
+  input text[]
+) returns text[] as $$
+DECLARE
+  i int;
+  output text[];
+  chunk text;
+  len int = cardinality(input);
+BEGIN
+  FOR i IN 1 .. len LOOP 
+    chunk = input[i];
+    IF (chunk ~* '[0-1]+') THEN 
+      chunk = replace(chunk, 'x', '0');
+    END IF;
+    output = array_append(output, chunk);
+  END LOOP;
+  RETURN output;
+END;
+$$
+LANGUAGE 'plpgsql' IMMUTABLE;
+
+  -- convert to decimal value
+
+  -- [01000, 01101, 10000, 10111, 01000, xxxxx, xxxxx, xxxxx]
+  -- [0b01000, 0b01101, 0b10000, 0b10111, 0b01000, xxxxx, xxxxx, xxxxx]
+  -- [ 8, 13, 16, 23, 8, '=', '=', '=' ]
+
+CREATE FUNCTION base32.to_decimal(
+  input text[]
+) returns text[] as $$
+DECLARE
+  i int;
+  output text[];
+  chunk text;
+  buf text;
+  len int = cardinality(input);
+BEGIN
+  FOR i IN 1 .. len LOOP 
+    chunk = input[i];
+    IF (chunk ~* '[x]+') THEN 
+      chunk = '=';
+    ELSE
+      chunk = base32.binary_to_int(input[i])::text;
+    END IF;
+    output = array_append(output, chunk);
+  END LOOP;
+  RETURN output;
+END;
+$$
+LANGUAGE 'plpgsql' IMMUTABLE;
+
+
+-- Table 3: The Base 32 Alphabet
+
+--   0 A             9 J            18 S            27 3
+--   1 B            10 K            19 T            28 4
+--   2 C            11 L            20 U            29 5
+--   3 D            12 M            21 V            30 6
+--   4 E            13 N            22 W            31 7
+--   5 F            14 O            23 X
+--   6 G            15 P            24 Y         (pad) =
+--   7 H            16 Q            25 Z
+--   8 I            17 R            26 2
+
+CREATE FUNCTION base32.base32_alphabet(
+  input int
+) returns char as $$
+DECLARE
+  alphabet text[] = ARRAY[
+    'A', 'B', 'C', 'D', 'E', 'F',
+    'G', 'H', 'I', 'J', 'K', 'L',
+    'M', 'N', 'O', 'P', 'Q', 'R',
+    'S', 'T', 'U', 'V', 'W', 'X',
+    'Y', 'Z', '2', '3', '4', '5',
+    '6', '7'
+  ]::text;
+BEGIN
+  RETURN alphabet[input+1];
+END;
+$$
+LANGUAGE 'plpgsql' IMMUTABLE;
+
+-- [ 8, 13, 16, 23, 8, '=', '=', '=' ]
+-- [ I, N, Q, X, I, '=', '=', '=' ]
+
+CREATE FUNCTION base32.to_base32(
+  input text[]
+) returns text as $$
+DECLARE
+  i int;
+  output text[];
+  chunk text;
+  buf text;
+  len int = cardinality(input);
+BEGIN
+  FOR i IN 1 .. len LOOP 
+    chunk = input[i];
+    IF (chunk = '=') THEN 
+      chunk = '=';
+    ELSE
+      chunk = base32.base32_alphabet(chunk::int);
+    END IF;
+    output = array_append(output, chunk);
+  END LOOP;
+  RETURN array_to_string(output, '');
+END;
+$$
+LANGUAGE 'plpgsql' IMMUTABLE;
+
+CREATE FUNCTION base32.encode(
+  input text
+) returns text as $$
+BEGIN
+  IF (character_length(input) = 0) THEN 
+    RETURN '';
+  END IF;
+
+  RETURN
+    base32.to_base32(
+      base32.to_decimal(
+        base32.fill_chunks(
+          base32.to_chunks(
+            base32.to_groups(
+              base32.to_binary(
+                base32.to_ascii(
+                  input
+                )
+              )
+            )
+          )
+        )
+      )
+    );
+END;
+$$
+LANGUAGE 'plpgsql' IMMUTABLE;
+
+COMMIT;

package/deploy/schemas/base32/schema.sql

@@ -0,0 +1,8 @@
+-- Deploy schemas/base32/schema to pg
+
+
+BEGIN;
+
+CREATE SCHEMA base32;
+
+COMMIT;

package/jest.config.js

@@ -0,0 +1,15 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+
+  // Match both __tests__ and colocated test files
+  testMatch: ['**/?(*.)+(test|spec).{ts,tsx,js,jsx}'],
+
+  // Ignore build artifacts and type declarations
+  testPathIgnorePatterns: ['/dist/', '\\.d\\.ts$'],
+  modulePathIgnorePatterns: ['<rootDir>/dist/'],
+  watchPathIgnorePatterns: ['/dist/'],
+
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
+};

package/launchql-base32.control

@@ -0,0 +1,8 @@
+# launchql-base32 extension
+comment = 'launchql-base32 extension'
+default_version = '0.4.6'
+module_pathname = '$libdir/launchql-base32'
+requires = 'pgcrypto,plpgsql,launchql-verify'
+relocatable = false
+superuser = false
+  

package/launchql.plan

@@ -0,0 +1,7 @@
+%syntax-version=1.0.0
+%project=launchql-base32
+%uri=launchql-base32
+  
+schemas/base32/schema 2017-08-11T08:11:51Z skitch <skitch@5b0c196eeb62> # add schemas/base32/schema
+schemas/base32/procedures/encode [schemas/base32/schema] 2017-08-11T08:11:51Z skitch <skitch@5b0c196eeb62> # add schemas/base32/procedures/encode
+schemas/base32/procedures/decode [schemas/base32/schema schemas/base32/procedures/encode] 2017-08-11T08:11:51Z skitch <skitch@5b0c196eeb62> # add schemas/base32/procedures/decode

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@pgpm/base32",
+  "version": "0.4.0",
+  "description": "Base32 encoding and decoding functions for PostgreSQL",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "bundle": "lql package",
+    "test": "jest",
+    "test:watch": "jest --watch"
+  },
+  "dependencies": {
+    "@pgpm/verify": "0.4.0"
+  },
+  "devDependencies": {
+    "@launchql/cli": "^4.9.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/launchql/extensions"
+  },
+  "homepage": "https://github.com/launchql/extensions",
+  "bugs": {
+    "url": "https://github.com/launchql/extensions/issues"
+  },
+  "gitHead": "cc9f52a335caa6e21ee7751b04b77c84ce6cb809"
+}

package/revert/schemas/base32/procedures/decode.sql

@@ -0,0 +1,13 @@
+-- Revert schemas/base32/procedures/decode from pg
+
+BEGIN;
+
+DROP FUNCTION base32.decode;
+DROP FUNCTION base32.valid;
+DROP FUNCTION base32.zero_fill;
+DROP FUNCTION base32.base32_alphabet_to_decimal_int;
+DROP FUNCTION base32.decimal_to_chunks;
+DROP FUNCTION base32.base32_to_decimal;
+DROP FUNCTION base32.base32_alphabet_to_decimal;
+
+COMMIT;

package/revert/schemas/base32/procedures/encode.sql

@@ -0,0 +1,18 @@
+-- Revert schemas/base32/procedures/encode from pg
+
+BEGIN;
+
+DROP FUNCTION base32.encode;
+DROP FUNCTION base32.to_base32;
+DROP FUNCTION base32.base32_alphabet;
+DROP FUNCTION base32.to_decimal;
+DROP FUNCTION base32.fill_chunks;
+DROP FUNCTION base32.to_chunks;
+DROP FUNCTION base32.string_nchars;
+DROP FUNCTION base32.to_groups;
+DROP FUNCTION base32.to_binary(int[]);
+DROP FUNCTION base32.to_binary(int);
+DROP FUNCTION base32.to_ascii;
+DROP FUNCTION base32.binary_to_int;
+
+COMMIT;

package/revert/schemas/base32/schema.sql

@@ -0,0 +1,7 @@
+-- Revert schemas/base32/schema from pg
+
+BEGIN;
+
+DROP SCHEMA base32 CASCADE;
+
+COMMIT;

package/sql/launchql-base32--0.4.6.sql

@@ -0,0 +1,327 @@
+\echo Use "CREATE EXTENSION launchql-base32" to load this file. \quit
+CREATE SCHEMA base32;
+
+CREATE FUNCTION base32.binary_to_int(input text) RETURNS int AS $EOFCODE$
+DECLARE
+  i int;
+  buf text;
+BEGIN
+    buf = 'SELECT B''' || input || '''::int';
+    EXECUTE buf INTO i;
+    RETURN i;
+END;
+$EOFCODE$ LANGUAGE plpgsql IMMUTABLE;
+
+CREATE FUNCTION base32.to_ascii(input text) RETURNS int[] AS $EOFCODE$
+DECLARE
+  i int;
+  output int[];
+BEGIN
+  FOR i IN 1 .. character_length(input) LOOP
+    output = array_append(output, ascii(substring(input from i for 1)));
+  END LOOP;
+  RETURN output;
+END;
+$EOFCODE$ LANGUAGE plpgsql IMMUTABLE;
+
+CREATE FUNCTION base32.to_binary(input int) RETURNS text AS $EOFCODE$
+DECLARE
+  i int = 1;
+  j int = 0;
+  output char[] = ARRAY['x', 'x', 'x', 'x', 'x', 'x', 'x', 'x'];
+BEGIN
+  WHILE i < 256 LOOP 
+    output[8-j] = (CASE WHEN (input & i) > 0 THEN '1' ELSE '0' END)::char;
+    i = i << 1;
+    j = j + 1;
+  END LOOP;
+  RETURN array_to_string(output, '');
+END;
+$EOFCODE$ LANGUAGE plpgsql IMMUTABLE;
+
+CREATE FUNCTION base32.to_binary(input int[]) RETURNS text[] AS $EOFCODE$
+DECLARE
+  i int;
+  output text[];
+BEGIN
+  FOR i IN 1 .. cardinality(input) LOOP
+    output = array_append(output, base32.to_binary(input[i]));  
+  END LOOP;
+  RETURN output;
+END;
+$EOFCODE$ LANGUAGE plpgsql IMMUTABLE;
+
+CREATE FUNCTION base32.to_groups(input text[]) RETURNS text[] AS $EOFCODE$
+DECLARE
+  i int;
+  output text[];
+  len int = cardinality(input);
+BEGIN
+  IF ( len % 5 = 0 ) THEN 
+    RETURN input;
+  END IF;
+  FOR i IN 1 .. 5 - (len % 5) LOOP
+    input = array_append(input, 'xxxxxxxx');
+  END LOOP;
+  RETURN input;
+END;
+$EOFCODE$ LANGUAGE plpgsql IMMUTABLE;
+
+CREATE FUNCTION base32.string_nchars(text, int) RETURNS text[] AS $EOFCODE$
+SELECT ARRAY(SELECT substring($1 from n for $2)
+  FROM generate_series(1, length($1), $2) n);
+$EOFCODE$ LANGUAGE sql IMMUTABLE;
+
+CREATE FUNCTION base32.to_chunks(input text[]) RETURNS text[] AS $EOFCODE$
+DECLARE
+  i int;
+  output text[];
+  str text;
+  len int = cardinality(input);
+BEGIN
+  RETURN base32.string_nchars(array_to_string(input, ''), 5);
+END;
+$EOFCODE$ LANGUAGE plpgsql IMMUTABLE;
+
+CREATE FUNCTION base32.fill_chunks(input text[]) RETURNS text[] AS $EOFCODE$
+DECLARE
+  i int;
+  output text[];
+  chunk text;
+  len int = cardinality(input);
+BEGIN
+  FOR i IN 1 .. len LOOP 
+    chunk = input[i];
+    IF (chunk ~* '[0-1]+') THEN 
+      chunk = replace(chunk, 'x', '0');
+    END IF;
+    output = array_append(output, chunk);
+  END LOOP;
+  RETURN output;
+END;
+$EOFCODE$ LANGUAGE plpgsql IMMUTABLE;
+
+CREATE FUNCTION base32.to_decimal(input text[]) RETURNS text[] AS $EOFCODE$
+DECLARE
+  i int;
+  output text[];
+  chunk text;
+  buf text;
+  len int = cardinality(input);
+BEGIN
+  FOR i IN 1 .. len LOOP 
+    chunk = input[i];
+    IF (chunk ~* '[x]+') THEN 
+      chunk = '=';
+    ELSE
+      chunk = base32.binary_to_int(input[i])::text;
+    END IF;
+    output = array_append(output, chunk);
+  END LOOP;
+  RETURN output;
+END;
+$EOFCODE$ LANGUAGE plpgsql IMMUTABLE;
+
+CREATE FUNCTION base32.base32_alphabet(input int) RETURNS char(1) AS $EOFCODE$
+DECLARE
+  alphabet text[] = ARRAY[
+    'A', 'B', 'C', 'D', 'E', 'F',
+    'G', 'H', 'I', 'J', 'K', 'L',
+    'M', 'N', 'O', 'P', 'Q', 'R',
+    'S', 'T', 'U', 'V', 'W', 'X',
+    'Y', 'Z', '2', '3', '4', '5',
+    '6', '7'
+  ]::text;
+BEGIN
+  RETURN alphabet[input+1];
+END;
+$EOFCODE$ LANGUAGE plpgsql IMMUTABLE;
+
+CREATE FUNCTION base32.to_base32(input text[]) RETURNS text AS $EOFCODE$
+DECLARE
+  i int;
+  output text[];
+  chunk text;
+  buf text;
+  len int = cardinality(input);
+BEGIN
+  FOR i IN 1 .. len LOOP 
+    chunk = input[i];
+    IF (chunk = '=') THEN 
+      chunk = '=';
+    ELSE
+      chunk = base32.base32_alphabet(chunk::int);
+    END IF;
+    output = array_append(output, chunk);
+  END LOOP;
+  RETURN array_to_string(output, '');
+END;
+$EOFCODE$ LANGUAGE plpgsql IMMUTABLE;
+
+CREATE FUNCTION base32.encode(input text) RETURNS text AS $EOFCODE$
+BEGIN
+  IF (character_length(input) = 0) THEN 
+    RETURN '';
+  END IF;
+
+  RETURN
+    base32.to_base32(
+      base32.to_decimal(
+        base32.fill_chunks(
+          base32.to_chunks(
+            base32.to_groups(
+              base32.to_binary(
+                base32.to_ascii(
+                  input
+                )
+              )
+            )
+          )
+        )
+      )
+    );
+END;
+$EOFCODE$ LANGUAGE plpgsql IMMUTABLE;
+
+CREATE FUNCTION base32.base32_alphabet_to_decimal(input text) RETURNS text AS $EOFCODE$
+DECLARE
+  alphabet text = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
+  alpha int;
+BEGIN
+  alpha = position(input in alphabet) - 1;
+  IF (alpha < 0) THEN 
+    RETURN '=';
+  END IF;
+  RETURN alpha::text;
+END;
+$EOFCODE$ LANGUAGE plpgsql IMMUTABLE;
+
+CREATE FUNCTION base32.base32_to_decimal(input text) RETURNS text[] AS $EOFCODE$
+DECLARE
+  i int;
+  output text[];
+BEGIN
+  input = upper(input);
+  FOR i IN 1 .. character_length(input) LOOP
+    output = array_append(output, base32.base32_alphabet_to_decimal(substring(input from i for 1)));
+  END LOOP;
+  RETURN output;
+END;
+$EOFCODE$ LANGUAGE plpgsql STABLE;
+
+CREATE FUNCTION base32.decimal_to_chunks(input text[]) RETURNS text[] AS $EOFCODE$
+DECLARE
+  i int;
+  part text;
+  output text[];
+BEGIN
+  FOR i IN 1 .. cardinality(input) LOOP
+    part = input[i];
+    IF (part = '=') THEN 
+      output = array_append(output, 'xxxxx');
+    ELSE
+      output = array_append(output, right(base32.to_binary(part::int), 5));
+    END IF;
+  END LOOP;
+  RETURN output;
+END;
+$EOFCODE$ LANGUAGE plpgsql STABLE;
+
+CREATE FUNCTION base32.base32_alphabet_to_decimal_int(input text) RETURNS int AS $EOFCODE$
+DECLARE
+  alphabet text = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
+  alpha int;
+BEGIN
+  alpha = position(input in alphabet) - 1;
+  RETURN alpha;
+END;
+$EOFCODE$ LANGUAGE plpgsql IMMUTABLE;
+
+CREATE FUNCTION base32.zero_fill(a int, b int) RETURNS bigint AS $EOFCODE$
+DECLARE
+  bin text;
+  m int;
+BEGIN
+
+  IF (b >= 32 OR b < -32) THEN 
+    m = b/32;
+    b = b-(m*32);
+  END IF;
+
+  IF (b < 0) THEN
+    b = 32 + b;
+  END IF;
+
+  IF (b = 0) THEN
+      return ((a>>1)&2147483647)*2::bigint+((a>>b)&1);
+  END IF;
+
+  IF (a < 0) THEN
+    a = (a >> 1); 
+    a = a & 2147483647; -- 0x7fffffff
+    a = a | 1073741824; -- 0x40000000
+    a = (a >> (b - 1)); 
+  ELSE
+    a = (a >> b); 
+  END IF; 
+
+  RETURN a;
+END;
+$EOFCODE$ LANGUAGE plpgsql IMMUTABLE;
+
+CREATE FUNCTION base32.valid(input text) RETURNS boolean AS $EOFCODE$
+BEGIN 
+  IF (upper(input) ~* '^[A-Z2-7]+=*$') THEN 
+    RETURN true;
+  END IF;
+  RETURN false;
+END;
+$EOFCODE$ LANGUAGE plpgsql IMMUTABLE;
+
+CREATE FUNCTION base32.decode(input text) RETURNS text AS $EOFCODE$
+DECLARE
+  i int;
+  arr int[];
+  output text[];
+  len int;
+  num int;
+
+  value int = 0;
+  index int = 0;
+  bits int = 0;
+BEGIN
+  len = character_length(input);
+  IF (len = 0) THEN 
+    RETURN '';
+  END IF;
+
+  IF (NOT base32.valid(input)) THEN 
+    RAISE EXCEPTION 'INVALID_BASE32';
+  END IF;
+
+  input = replace(input, '=', '');
+  input = upper(input);
+  len = character_length(input);
+  num = len * 5 / 8;
+
+  select array(select * from generate_series(1,num))
+  INTO arr;
+  
+  FOR i IN 1 .. len LOOP
+    value = (value << 5) | base32.base32_alphabet_to_decimal_int(substring(input from i for 1));
+    bits = bits + 5;
+    IF (bits >= 8) THEN
+      arr[index] = base32.zero_fill(value, (bits - 8)) & 255; -- arr[index] = (value >>> (bits - 8)) & 255;
+      index = index + 1;
+      bits = bits - 8;
+    END IF;
+  END LOOP;
+
+  len = cardinality(arr);
+  FOR i IN 0 .. len-2 LOOP
+     output = array_append(output, chr(arr[i]));
+  END LOOP;
+
+  RETURN array_to_string(output, '');
+END;
+$EOFCODE$ LANGUAGE plpgsql STABLE;

package/verify/schemas/base32/procedures/decode.sql

@@ -0,0 +1,7 @@
+-- Verify schemas/base32/procedures/decode  on pg
+
+BEGIN;
+
+SELECT verify_function ('base32.decode');
+
+ROLLBACK;

package/verify/schemas/base32/procedures/encode.sql

@@ -0,0 +1,7 @@
+-- Verify schemas/base32/procedures/encode  on pg
+
+BEGIN;
+
+SELECT verify_function ('base32.encode');
+
+ROLLBACK;

package/verify/schemas/base32/schema.sql

@@ -0,0 +1,7 @@
+-- Verify schemas/base32/schema  on pg
+
+BEGIN;
+
+SELECT verify_schema ('base32');
+
+ROLLBACK;