@pgpm/inflection 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-inflection
+DATA = sql/launchql-inflection--0.4.7.sql
+
+PG_CONFIG = pg_config
+PGXS := $(shell $(PG_CONFIG) --pgxs)
+include $(PGXS)

package/README.md

@@ -0,0 +1,5 @@
+# @pgpm/inflection
+
+String inflection utilities for PostgreSQL naming conventions.
+
+Provides string transformation functions for converting between different naming conventions (camelCase, snake_case, etc.) in PostgreSQL.

package/__tests__/inflection.test.ts

@@ -0,0 +1,181 @@
+import cases from 'jest-in-case';
+import { getConnections, PgTestClient } from 'pgsql-test';
+
+let pg: PgTestClient;
+let teardown: () => Promise<void>;
+
+describe('inflection', () => {
+  beforeAll(async () => {
+    ({ pg, teardown } = await getConnections());
+  });
+
+  afterAll(async () => {
+    await teardown();
+  });
+
+  cases(
+    'slugify',
+    async (opts: { name: string; allowUnicode: boolean; result: string }) => {
+      const { pg_slugify } = await pg.one(
+        'SELECT * FROM inflection.pg_slugify($1, $2)',
+        [opts.name, opts.allowUnicode]
+      );
+      expect(pg_slugify).toEqual(opts.result);
+    },
+    [
+      { name: 'Hello, World!', allowUnicode: false, result: 'Hello_World' },
+      { name: 'Héllø, Wørld!', allowUnicode: false, result: 'Hello_World' },
+      { name: 'spam & eggs', allowUnicode: false, result: 'spam_eggs' },
+      { name: 'spam & ıçüş', allowUnicode: true, result: 'spam_ıçüş' },
+      { name: 'foo ıç bar', allowUnicode: true, result: 'foo_ıç_bar' },
+      { name: '    foo ıç bar', allowUnicode: true, result: 'foo_ıç_bar' },
+      { name: '你好', allowUnicode: true, result: '你好' },
+      { name: 'message_properties', allowUnicode: false, result: 'message_properties' },
+      { name: 'MessageProperties', allowUnicode: false, result: 'MessageProperties' },
+      { name: 'WebACL', allowUnicode: false, result: 'WebAcl' }
+    ]
+  );
+
+  cases(
+    'underscore',
+    async (opts: { name: string; result: string }) => {
+      const { underscore } = await pg.one(
+        'SELECT * FROM inflection.underscore($1)',
+        [opts.name]
+      );
+      expect(underscore).toEqual(opts.result);
+    },
+    [
+      { name: 'MessageProperties', result: 'message_properties' },
+      { name: 'messageProperties', result: 'message_properties' },
+      { name: 'message_properties', result: 'message_properties' },
+      { name: 'User Post', result: 'user_post' },
+      { name: 'MP', result: 'mp' },
+      { name: 'WebACL', result: 'web_acl' },
+      { name: 'wabCdEfgh', result: 'wab_cd_efgh' },
+      { name: 'WabCDEfgH', result: 'wab_cd_efgh' }
+    ]
+  );
+
+  cases(
+    'no_single_underscores',
+    async (opts: { name: string; result: string }) => {
+      const { no_single_underscores } = await pg.one(
+        'SELECT * FROM inflection.no_single_underscores($1)',
+        [opts.name]
+      );
+      expect(no_single_underscores).toEqual(opts.result);
+    },
+    [
+      { name: 'w_a_b_cd_efg_h', result: 'wab_cd_efgh' }
+    ]
+  );
+
+  cases(
+    'pascal',
+    async (opts: { name: string; result: string }) => {
+      const { pascal } = await pg.one(
+        'SELECT * FROM inflection.pascal($1)',
+        [opts.name]
+      );
+      expect(pascal).toEqual(opts.result);
+    },
+    [
+      { name: 'MessageProperties', result: 'MessageProperties' },
+      { name: 'message_properties', result: 'MessageProperties' },
+      { name: 'messageProperties', result: 'MessageProperties' },
+      { name: 'MP', result: 'Mp' },
+      { name: 'WebAcl', result: 'WebAcl' },
+      { name: 'WebACL', result: 'WebAcl' },
+      { name: 'web_acl', result: 'WebAcl' },
+      { name: 'web acl', result: 'WebAcl' },
+      { name: 'Web Acl', result: 'WebAcl' },
+      { name: 'Web ACL', result: 'WebAcl' },
+      { name: 'w_a_b', result: 'Wab' }
+    ]
+  );
+
+  cases(
+    'camel',
+    async (opts: { name: string; result: string }) => {
+      const { camel } = await pg.one(
+        'SELECT * FROM inflection.camel($1)',
+        [opts.name]
+      );
+      expect(camel).toEqual(opts.result);
+    },
+    [
+      { name: 'MessageProperties', result: 'messageProperties' },
+      { name: 'message_properties', result: 'messageProperties' },
+      { name: 'messageProperties', result: 'messageProperties' },
+      { name: 'MP', result: 'mp' },
+      { name: 'webAcl', result: 'webAcl' },
+      { name: 'WebACL', result: 'webAcl' },
+      { name: 'web_acl', result: 'webAcl' },
+      { name: 'web acl', result: 'webAcl' },
+      { name: 'Web Acl', result: 'webAcl' },
+      { name: 'Web ACL', result: 'webAcl' },
+      { name: 'w_a_b', result: 'wab' },
+      { name: 'w_a_b_cd_efg_h', result: 'wabCdEfgh' }
+    ]
+  );
+
+  cases(
+    'no_consecutive_caps',
+    async (opts: { name: string; result: string }) => {
+      const { no_consecutive_caps } = await pg.one(
+        'SELECT * FROM inflection.no_consecutive_caps($1)',
+        [opts.name]
+      );
+      expect(no_consecutive_caps).toEqual(opts.result);
+    },
+    [
+      { name: 'MP', result: 'Mp' },
+      { name: 'Web_ACL', result: 'Web_Acl' },
+      { name: 'MPComplete', result: 'MpComplete' },
+      { name: 'ACLWindow', result: 'AclWindow' }
+    ]
+  );
+
+  cases(
+    'plural',
+    async (opts: { name: string; result: string }) => {
+      const { plural } = await pg.one(
+        'SELECT * FROM inflection.plural($1)',
+        [opts.name]
+      );
+      expect(plural).toEqual(opts.result);
+    },
+    [
+      { name: 'user_login', result: 'user_logins' },
+      { name: 'user Login', result: 'user Logins' },
+      { name: 'user_logins', result: 'user_logins' },
+      { name: 'user Logins', result: 'user Logins' },
+      { name: 'children', result: 'children' },
+      { name: 'child', result: 'children' },
+      { name: 'man', result: 'men' },
+      { name: 'men', result: 'men' }
+    ]
+  );
+
+  cases(
+    'singular',
+    async (opts: { name: string; result: string }) => {
+      const { singular } = await pg.one(
+        'SELECT * FROM inflection.singular($1)',
+        [opts.name]
+      );
+      expect(singular).toEqual(opts.result);
+    },
+    [
+      { name: 'user_logins', result: 'user_login' },
+      { name: 'user Logins', result: 'user Login' },
+      { name: 'user_login', result: 'user_login' },
+      { name: 'user Login', result: 'user Login' },
+      { name: 'children', result: 'child' },
+      { name: 'child', result: 'child' },
+      { name: 'man', result: 'man' },
+      { name: 'men', result: 'man' }
+    ]
+  );
+});

package/deploy/schemas/inflection/procedures/camel.sql

@@ -0,0 +1,25 @@
+-- Deploy schemas/inflection/procedures/camel to pg
+
+-- requires: schemas/inflection/schema
+-- requires: schemas/inflection/procedures/underscore
+
+BEGIN;
+
+CREATE FUNCTION inflection.camel (str text)
+  RETURNS text
+  AS $$
+DECLARE
+  result text[];
+BEGIN
+    str = inflection.underscore(str);
+    FOR result IN
+    SELECT regexp_matches(str,  E'(_[a-zA-Z0-9])', 'g')
+      LOOP
+        str = replace(str, result[1], upper(result[1]));
+      END LOOP;
+  return regexp_replace(substring(str FROM 1 FOR 1) || substring(str FROM 2 FOR length(str)), E'[_]+', '', 'gi');
+END;
+$$
+LANGUAGE 'plpgsql' STABLE;
+
+COMMIT;

package/deploy/schemas/inflection/procedures/dashed.sql

@@ -0,0 +1,29 @@
+-- Deploy schemas/inflection/procedures/dashed to pg
+
+-- requires: schemas/inflection/schema
+-- requires: schemas/inflection/procedures/underscore
+
+BEGIN;
+
+CREATE FUNCTION inflection.dashed(str text)
+  RETURNS text
+  AS $$
+  WITH underscored AS (
+    SELECT
+      inflection.underscore(str) AS value
+),
+dashes AS (
+  SELECT
+    regexp_replace(value, '_', '-', 'gi') AS value
+  FROM
+    underscored
+)
+SELECT
+  value
+FROM
+  dashes;
+$$
+LANGUAGE 'sql'
+IMMUTABLE;
+COMMIT;
+

package/deploy/schemas/inflection/procedures/no_consecutive_caps.sql

@@ -0,0 +1,53 @@
+-- Deploy schemas/inflection/procedures/no_consecutive_caps to pg
+
+-- requires: schemas/inflection/schema
+
+BEGIN;
+
+CREATE FUNCTION inflection.no_consecutive_caps_till_end(
+  str text
+) returns text as $$
+DECLARE
+  result text[];
+  temp text;
+BEGIN
+    FOR result IN
+    SELECT regexp_matches(str, E'([A-Z])([A-Z]+$)', 'g')
+      LOOP
+        temp = result[1] || lower(result[2]);
+        str = replace(str, result[1] || result[2], temp);
+      END LOOP;
+  return str;
+END;
+$$
+LANGUAGE 'plpgsql' STABLE;
+
+
+CREATE FUNCTION inflection.no_consecutive_caps_till_lower(
+  str text
+) returns text as $$
+DECLARE
+  result text[];
+  temp text;
+BEGIN
+    FOR result IN
+    SELECT regexp_matches(str, E'([A-Z])([A-Z]+)[A-Z][a-z]', 'g')
+      LOOP
+        temp = result[1] || lower(result[2]);
+        str = replace(str, result[1] || result[2], temp);
+      END LOOP;
+
+  return str;
+END;
+$$
+LANGUAGE 'plpgsql' STABLE;
+
+
+CREATE FUNCTION inflection.no_consecutive_caps(
+  str text
+) returns text as $$
+  select inflection.no_consecutive_caps_till_lower(inflection.no_consecutive_caps_till_end(str));
+$$
+LANGUAGE 'sql' STABLE;
+
+COMMIT;

package/deploy/schemas/inflection/procedures/no_single_underscores.sql

@@ -0,0 +1,70 @@
+-- Deploy schemas/inflection/procedures/no_single_underscores to pg
+
+-- requires: schemas/inflection/schema
+
+BEGIN;
+
+CREATE FUNCTION inflection.no_single_underscores_in_beginning(
+  str text
+) returns text as $$
+DECLARE
+  result text[];
+  temp text;
+BEGIN
+    FOR result IN
+    SELECT regexp_matches(str, E'(^[a-z])(_)', 'g')
+      LOOP
+        str = replace(str, result[1] || result[2], result[1]);
+      END LOOP;
+  return str;
+END;
+$$
+LANGUAGE 'plpgsql' STABLE;
+
+
+CREATE FUNCTION inflection.no_single_underscores_at_end(
+  str text
+) returns text as $$
+DECLARE
+  result text[];
+  temp text;
+BEGIN
+    FOR result IN
+    SELECT regexp_matches(str, E'(_)([a-z]$)', 'g')
+      LOOP
+        str = replace(str, result[1] || result[2], result[2]);
+      END LOOP;
+
+  return str;
+END;
+$$
+LANGUAGE 'plpgsql' STABLE;
+
+CREATE FUNCTION inflection.no_single_underscores_in_middle(
+  str text
+) returns text as $$
+DECLARE
+  result text[];
+  temp text;
+BEGIN
+    FOR result IN
+    SELECT regexp_matches(str, E'(_)([a-z]_)', 'g')
+      LOOP
+        str = replace(str, result[1] || result[2], result[2]);
+      END LOOP;
+
+  return str;
+END;
+$$
+LANGUAGE 'plpgsql' STABLE;
+
+
+CREATE FUNCTION inflection.no_single_underscores(
+  str text
+) returns text as $$
+  select 
+    inflection.no_single_underscores_in_middle(inflection.no_single_underscores_at_end(inflection.no_single_underscores_in_beginning(str)));
+$$
+LANGUAGE 'sql' STABLE;
+
+COMMIT;

package/deploy/schemas/inflection/procedures/pascal.sql

@@ -0,0 +1,20 @@
+-- Deploy schemas/inflection/procedures/pascal to pg
+-- requires: schemas/inflection/schema
+-- requires: schemas/inflection/procedures/camel
+
+BEGIN;
+
+CREATE FUNCTION inflection.pascal (str text)
+  RETURNS text
+  AS $$
+DECLARE
+  result text[];
+BEGIN
+    str = inflection.camel(str);
+  return upper(substring(str FROM 1 FOR 1)) || substring(str FROM 2 FOR length(str));
+END;
+$$
+LANGUAGE 'plpgsql' STABLE;
+
+COMMIT;
+

package/deploy/schemas/inflection/procedures/pg_slugify.sql

@@ -0,0 +1,68 @@
+-- Deploy schemas/inflection/procedures/pg_slugify to pg
+-- requires: schemas/inflection/schema
+-- requires: schemas/inflection/procedures/no_consecutive_caps
+-- NOTE: this does NOT lowercase, and uses underscores instead of dashes
+
+BEGIN;
+CREATE FUNCTION inflection.pg_slugify (value text, allow_unicode boolean)
+  RETURNS text
+  AS $$
+  WITH normalized AS (
+    SELECT
+      CASE WHEN allow_unicode THEN
+        value
+      ELSE
+        unaccent (value)
+      END AS value
+),
+no_consecutive_caps AS (
+  SELECT
+    inflection.no_consecutive_caps (value) AS value
+FROM
+  normalized
+),
+remove_chars AS (
+  SELECT
+    regexp_replace(value, E'[^\\w\\s-]', '', 'gi') AS value
+FROM
+  no_consecutive_caps
+),
+trimmed AS (
+  SELECT
+    trim(value) AS value
+FROM
+  remove_chars
+),
+hyphenated AS (
+  SELECT
+    regexp_replace(value, E'[-\\s]+', '-', 'gi') AS value
+FROM
+  trimmed
+),
+underscored AS (
+  SELECT
+    regexp_replace(value, E'[-]+', '_', 'gi') AS value
+FROM
+  hyphenated
+),
+removedups AS (
+  SELECT
+    regexp_replace(value, E'[_]+', '_', 'gi') AS value
+FROM
+  underscored
+)
+SELECT
+  value
+FROM
+  removedups;
+$$
+LANGUAGE SQL
+STRICT IMMUTABLE;
+-- default false overload
+CREATE FUNCTION inflection.pg_slugify (text)
+  RETURNS text
+  AS 'SELECT inflection.pg_slugify($1, false)'
+  LANGUAGE SQL
+  IMMUTABLE;
+COMMIT;
+

package/deploy/schemas/inflection/procedures/plural.sql

@@ -0,0 +1,31 @@
+-- Deploy schemas/inflection/procedures/plural to pg
+
+-- requires: schemas/inflection/schema
+-- requires: schemas/inflection/tables/inflection_rules/table
+
+BEGIN;
+
+CREATE FUNCTION inflection.plural (str text)
+  RETURNS text
+  AS $$
+DECLARE
+  result record;
+  matches text[];
+BEGIN
+    FOR result IN
+    SELECT * FROM inflection.inflection_rules where type='plural'
+      LOOP
+        matches = regexp_matches(str, result.test, 'gi');
+        IF (array_length(matches, 1) > 0) THEN
+           IF (result.replacement IS NULL) THEN
+				return str;        
+           END IF;
+           str = regexp_replace(str, result.test, result.replacement, 'gi');
+           return str;
+        END IF;
+      END LOOP;
+  return str;
+END;
+$$
+LANGUAGE 'plpgsql' IMMUTABLE;
+COMMIT;

package/deploy/schemas/inflection/procedures/should_skip_uncountable.sql

@@ -0,0 +1,17 @@
+-- Deploy schemas/inflection/procedures/should_skip_uncountable to pg
+-- requires: schemas/inflection/schema
+-- requires: schemas/inflection/procedures/uncountable_words
+
+BEGIN;
+
+CREATE FUNCTION inflection.should_skip_uncountable (str text)
+  RETURNS boolean
+  AS $$
+  SELECT
+    str = ANY (inflection.uncountable_words ());
+$$
+LANGUAGE 'sql'
+IMMUTABLE;
+
+COMMIT;
+

package/deploy/schemas/inflection/procedures/singular.sql

@@ -0,0 +1,31 @@
+-- Deploy schemas/inflection/procedures/singular to pg
+
+-- requires: schemas/inflection/schema
+-- requires: schemas/inflection/tables/inflection_rules/table
+
+BEGIN;
+
+CREATE FUNCTION inflection.singular (str text)
+  RETURNS text
+  AS $$
+DECLARE
+  result record;
+  matches text[];
+BEGIN
+    FOR result IN
+    SELECT * FROM inflection.inflection_rules where type='singular'
+      LOOP
+        matches = regexp_matches(str, result.test, 'gi');
+        IF (array_length(matches, 1) > 0) THEN
+           IF (result.replacement IS NULL) THEN
+				return str;        
+           END IF;
+           str = regexp_replace(str, result.test, result.replacement, 'gi');
+           return str;
+        END IF;
+      END LOOP;
+  return str;
+END;
+$$
+LANGUAGE 'plpgsql' IMMUTABLE;
+COMMIT;

package/deploy/schemas/inflection/procedures/slugify.sql

@@ -0,0 +1,59 @@
+-- Deploy schemas/inflection/procedures/slugify to pg
+
+-- requires: schemas/inflection/schema
+
+-- https://schinckel.net/2015/12/16/slugify()-for-postgres-(almost)/
+
+BEGIN;
+CREATE FUNCTION inflection.slugify (value text, allow_unicode boolean)
+  RETURNS text
+  AS $$
+  WITH normalized AS (
+    SELECT
+      CASE WHEN allow_unicode THEN
+        value
+      ELSE
+        unaccent (value)
+      END AS value
+),
+remove_chars AS (
+  SELECT
+    regexp_replace(value, E'[^\\w\\s-]', '', 'gi') AS value
+FROM
+  normalized
+),
+lowercase AS (
+  SELECT
+    lower(value) AS value
+FROM
+  remove_chars
+),
+trimmed AS (
+  SELECT
+    trim(value) AS value
+FROM
+  lowercase
+),
+hyphenated AS (
+  SELECT
+    regexp_replace(value, E'[-\\s]+', '-', 'gi') AS value
+FROM
+  trimmed
+)
+SELECT
+  value
+FROM
+  hyphenated;
+$$
+LANGUAGE SQL
+STRICT IMMUTABLE;
+
+-- default false overload
+CREATE FUNCTION inflection.slugify (text)
+  RETURNS text
+  AS 'SELECT inflection.slugify($1, false)'
+  LANGUAGE SQL
+  IMMUTABLE;
+
+
+COMMIT;

package/deploy/schemas/inflection/procedures/uncountable_words.sql

@@ -0,0 +1,14 @@
+-- Deploy schemas/inflection/procedures/uncountable_words to pg
+
+-- requires: schemas/inflection/schema
+
+BEGIN;
+
+CREATE FUNCTION inflection.uncountable_words ()
+  RETURNS text[]
+  AS $$
+select ARRAY[ 'accommodation', 'adulthood', 'advertising', 'advice', 'aggression', 'aid', 'air', 'aircraft', 'alcohol', 'anger', 'applause', 'arithmetic', 'assistance', 'athletics', 'bacon', 'baggage', 'beef', 'biology', 'blood', 'botany', 'bread', 'butter', 'carbon', 'cardboard', 'cash', 'chalk', 'chaos', 'chess', 'crossroads', 'countryside', 'dancing', 'deer', 'dignity', 'dirt', 'dust', 'economics', 'education', 'electricity', 'engineering', 'enjoyment', 'envy', 'equipment', 'ethics', 'evidence', 'evolution', 'fame', 'fiction', 'flour', 'flu', 'food', 'fuel', 'fun', 'furniture', 'gallows', 'garbage', 'garlic', 'genetics', 'gold', 'golf', 'gossip', 'grammar', 'gratitude', 'grief', 'guilt', 'gymnastics', 'happiness', 'hardware', 'harm', 'hate', 'hatred', 'health', 'heat', 'help', 'homework', 'honesty', 'honey', 'hospitality', 'housework', 'humour', 'hunger', 'hydrogen', 'ice', 'importance', 'inflation', 'information', 'innocence', 'iron', 'irony', 'jam', 'jewelry', 'judo', 'karate', 'knowledge', 'lack', 'laughter', 'lava', 'leather', 'leisure', 'lightning', 'linguine', 'linguini', 'linguistics', 'literature', 'litter', 'livestock', 'logic', 'loneliness', 'luck', 'luggage', 'macaroni', 'machinery', 'magic', 'management', 'mankind', 'marble', 'mathematics', 'mayonnaise', 'measles', 'methane', 'milk', 'minus', 'money', 'mud', 'music', 'mumps', 'nature', 'news', 'nitrogen', 'nonsense', 'nurture', 'nutrition', 'obedience', 'obesity', 'oxygen', 'pasta', 'patience', 'physics', 'poetry', 'pollution', 'poverty', 'pride', 'psychology', 'publicity', 'punctuation', 'quartz', 'racism', 'relaxation', 'reliability', 'research', 'respect', 'revenge', 'rice', 'rubbish', 'rum', 'safety', 'scenery', 'seafood', 'seaside', 'series', 'shame', 'sheep', 'shopping', 'sleep', 'smoke', 'smoking', 'snow', 'soap', 'software', 'soil', 'spaghetti', 'species', 'steam', 'stuff', 'stupidity', 'sunshine', 'symmetry', 'tennis', 'thirst', 'thunder', 'timber', 'traffic', 'transportation', 'trust', 'underwear', 'unemployment', 'unity', 'validity', 'veal', 'vegetation', 'vegetarianism', 'vengeance', 'violence', 'vitality', 'warmth', 'wealth', 'weather', 'welfare', 'wheat', 'wildlife', 'wisdom', 'yoga', 'zinc', 'zoology' ];
+$$
+LANGUAGE 'sql' IMMUTABLE;
+
+COMMIT;