iam-floyd 0.847.0 → 0.849.0

package/dotnet/src/IAM.Floyd/Js.cs

@@ -0,0 +1,272 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Text;
+using System.Text.RegularExpressions;
+
+namespace IAM.Floyd;
+
+/// <summary>
+/// The semantics of JavaScript that the transpiled code relies on.
+/// </summary>
+internal static class Js
+{
+    /// <summary>
+    /// Whether a value is a number.
+    /// </summary>
+    public static bool IsNumber(object value)
+    {
+        return value is double || value is int || value is long || value is float
+            || value is short || value is byte || value is decimal;
+    }
+
+    /// <summary>
+    /// Array.isArray: whether a value is a sequence, other than a string or a dictionary.
+    /// </summary>
+    public static bool IsArray(object value)
+    {
+        return value is IEnumerable && !(value is string) && !(value is IDictionary);
+    }
+
+    /// <summary>
+    /// A sequence as list.
+    /// </summary>
+    public static List<object> ToList(object value)
+    {
+        var result = new List<object>();
+        foreach (var item in (IEnumerable)value)
+        {
+            result.Add(item);
+        }
+        return result;
+    }
+
+    /// <summary>
+    /// The result of the typeof operator of JavaScript.
+    /// </summary>
+    public static string Typeof(object value)
+    {
+        if (value == null)
+        {
+            return "undefined";
+        }
+        if (value is bool)
+        {
+            return "boolean";
+        }
+        if (IsNumber(value))
+        {
+            return "number";
+        }
+        if (value is string)
+        {
+            return "string";
+        }
+        return "object";
+    }
+
+    /// <summary>
+    /// A value as JavaScript converts it to a string.
+    /// </summary>
+    public static string ToString(object value)
+    {
+        switch (value)
+        {
+            case null:
+                return "undefined";
+            case string text:
+                return text;
+            case bool flag:
+                return flag ? "true" : "false";
+            case double number:
+                return Number(number);
+            case float number:
+                return Number(number);
+            case decimal number:
+                return Number((double)number);
+            case IFormattable formattable when IsNumber(value):
+                return formattable.ToString(null, CultureInfo.InvariantCulture);
+            case IEnumerable items when !(value is IDictionary):
+                var result = new StringBuilder();
+                var first = true;
+                foreach (var item in items)
+                {
+                    if (!first)
+                    {
+                        result.Append(',');
+                    }
+                    first = false;
+                    if (item != null)
+                    {
+                        result.Append(ToString(item));
+                    }
+                }
+                return result.ToString();
+        }
+        return value.ToString();
+    }
+
+    /// <summary>
+    /// A number as JavaScript formats it: the shortest digits that round-trip.
+    /// </summary>
+    public static string Number(double value)
+    {
+        if (double.IsNaN(value))
+        {
+            return "NaN";
+        }
+        if (double.IsInfinity(value))
+        {
+            return value > 0 ? "Infinity" : "-Infinity";
+        }
+        if (value == 0)
+        {
+            return "0";
+        }
+        if (value < 0)
+        {
+            return "-" + Number(-value);
+        }
+        // the shortest representation that parses back to the same value, e.g. 1.5E-07
+        var shortest = value.ToString("R", CultureInfo.InvariantCulture);
+        var e = shortest.IndexOf('E');
+        var mantissa = e < 0 ? shortest : shortest.Substring(0, e);
+        var exponent = e < 0 ? 0 : int.Parse(shortest.Substring(e + 1), CultureInfo.InvariantCulture);
+        var point = mantissa.IndexOf('.');
+        var digits = point < 0 ? mantissa : mantissa.Remove(point, 1);
+        // n is the position of the decimal point relative to the first digit
+        var n = (point < 0 ? mantissa.Length : point) + exponent;
+        while (digits.Length > 1 && digits[0] == '0')
+        {
+            digits = digits.Substring(1);
+            n--;
+        }
+        // trailing zeros are not significant
+        while (digits.Length > 1 && digits[digits.Length - 1] == '0')
+        {
+            digits = digits.Substring(0, digits.Length - 1);
+        }
+        var k = digits.Length;
+        var result = new StringBuilder();
+        if (k <= n && n <= 21)
+        {
+            result.Append(digits).Append('0', n - k);
+        }
+        else if (0 < n && n <= 21)
+        {
+            result.Append(digits, 0, n).Append('.').Append(digits.Substring(n));
+        }
+        else if (-6 < n && n <= 0)
+        {
+            result.Append("0.").Append('0', -n).Append(digits);
+        }
+        else
+        {
+            result.Append(digits[0]);
+            if (k > 1)
+            {
+                result.Append('.').Append(digits.Substring(1));
+            }
+            result.Append('e').Append(n - 1 >= 0 ? "+" : "-")
+                .Append(Math.Abs(n - 1).ToString(CultureInfo.InvariantCulture));
+        }
+        return result.ToString();
+    }
+
+    /// <summary>
+    /// String.prototype.substring: the indexes are clamped, and swapped if start is after end.
+    /// </summary>
+    public static string Substring(string value, int start)
+    {
+        return Substring(value, start, value.Length);
+    }
+
+    /// <summary>
+    /// String.prototype.substring: the indexes are clamped, and swapped if start is after end.
+    /// </summary>
+    public static string Substring(string value, int start, int end)
+    {
+        start = Math.Max(0, Math.Min(start, value.Length));
+        end = Math.Max(0, Math.Min(end, value.Length));
+        return start <= end
+            ? value.Substring(start, end - start)
+            : value.Substring(end, start - end);
+    }
+
+    /// <summary>
+    /// Array.prototype.filter.
+    /// </summary>
+    public static List<T> Filter<T>(List<T> list, Func<T, int, bool> predicate)
+    {
+        var result = new List<T>();
+        for (var i = 0; i < list.Count; i++)
+        {
+            if (predicate(list[i], i))
+            {
+                result.Add(list[i]);
+            }
+        }
+        return result;
+    }
+
+    /// <summary>
+    /// Array.prototype.map.
+    /// </summary>
+    public static List<TResult> Map<T, TResult>(List<T> list, Func<T, int, TResult> fn)
+    {
+        var result = new List<TResult>();
+        for (var i = 0; i < list.Count; i++)
+        {
+            result.Add(fn(list[i], i));
+        }
+        return result;
+    }
+
+    /// <summary>
+    /// Array.prototype.sort without compare function: sorts strings by UTF-16 code units.
+    /// </summary>
+    public static List<string> Sort(List<string> list)
+    {
+        list.Sort(string.CompareOrdinal);
+        return list;
+    }
+
+    /// <summary>
+    /// Date.prototype.toISOString. Dates of an unspecified kind are in UTC.
+    /// </summary>
+    public static string ToISOString(DateTime value)
+    {
+        if (value.Kind == DateTimeKind.Local)
+        {
+            value = value.ToUniversalTime();
+        }
+        return value.ToString("yyyy-MM-dd'T'HH:mm:ss.fff'Z'", CultureInfo.InvariantCulture);
+    }
+
+    /// <summary>
+    /// A regular expression like new RegExp(pattern, flags), with the flags i, m and s.
+    /// </summary>
+    public static Regex RegExp(string pattern, string flags)
+    {
+        var options = RegexOptions.None;
+        foreach (var flag in flags)
+        {
+            switch (flag)
+            {
+                case 'i':
+                    options |= RegexOptions.IgnoreCase | RegexOptions.CultureInvariant;
+                    break;
+                case 'm':
+                    options |= RegexOptions.Multiline;
+                    break;
+                case 's':
+                    options |= RegexOptions.Singleline;
+                    break;
+                default:
+                    throw new ArgumentException("Unsupported regular expression flag: " + flag);
+            }
+        }
+        return new Regex(pattern, options);
+    }
+}

package/dotnet/src/IAM.Floyd/Json.cs

@@ -0,0 +1,151 @@
+using System;
+using System.Collections;
+using System.Globalization;
+using System.Reflection;
+using System.Text;
+
+namespace IAM.Floyd;
+
+/// <summary>
+/// Serializes statements and their parts to JSON, as <c>JSON.stringify</c> of JavaScript.
+/// </summary>
+public static class Json
+{
+    /// <summary>
+    /// The JSON of a value: dictionaries in the order of their keys, sequences, strings, numbers,
+    /// booleans, null, dates as ISO strings, and objects with a public <c>ToJSON()</c> method, such
+    /// as statements.
+    /// </summary>
+    /// <param name="value">The value</param>
+    /// <returns>The JSON, without whitespace</returns>
+    public static string Stringify(object value)
+    {
+        var result = new StringBuilder();
+        Write(result, value);
+        return result.ToString();
+    }
+
+    private static void Write(StringBuilder result, object value)
+    {
+        switch (value)
+        {
+            case null:
+                result.Append("null");
+                break;
+            case string text:
+                WriteString(result, text);
+                break;
+            case bool flag:
+                result.Append(flag ? "true" : "false");
+                break;
+            case double or float or decimal:
+                var number = Convert.ToDouble(value, CultureInfo.InvariantCulture);
+                result.Append(double.IsNaN(number) || double.IsInfinity(number) ? "null" : Js.Number(number));
+                break;
+            case IFormattable formattable when Js.IsNumber(value):
+                result.Append(formattable.ToString(null, CultureInfo.InvariantCulture));
+                break;
+            case DateTime date:
+                WriteString(result, Js.ToISOString(date));
+                break;
+            case IDictionary dictionary:
+                result.Append('{');
+                var first = true;
+                foreach (DictionaryEntry entry in dictionary)
+                {
+                    if (!first)
+                    {
+                        result.Append(',');
+                    }
+                    first = false;
+                    WriteString(result, Convert.ToString(entry.Key, CultureInfo.InvariantCulture));
+                    result.Append(':');
+                    Write(result, entry.Value);
+                }
+                result.Append('}');
+                break;
+            case IEnumerable items:
+                result.Append('[');
+                var firstItem = true;
+                foreach (var item in items)
+                {
+                    if (!firstItem)
+                    {
+                        result.Append(',');
+                    }
+                    firstItem = false;
+                    Write(result, item);
+                }
+                result.Append(']');
+                break;
+            default:
+                Write(result, ToJson(value));
+                break;
+        }
+    }
+
+    private static object ToJson(object value)
+    {
+        var method = value.GetType().GetMethod("ToJSON", Type.EmptyTypes);
+        if (method == null)
+        {
+            throw new ArgumentException("Cannot serialize " + value.GetType().FullName + " to JSON");
+        }
+        try
+        {
+            return method.Invoke(value, null);
+        }
+        catch (TargetInvocationException e) when (e.InnerException != null)
+        {
+            System.Runtime.ExceptionServices.ExceptionDispatchInfo.Capture(e.InnerException).Throw();
+            throw;
+        }
+    }
+
+    private static void WriteString(StringBuilder result, string value)
+    {
+        result.Append('"');
+        for (var i = 0; i < value.Length; i++)
+        {
+            var c = value[i];
+            switch (c)
+            {
+                case '"':
+                    result.Append("\\\"");
+                    break;
+                case '\\':
+                    result.Append("\\\\");
+                    break;
+                case '\b':
+                    result.Append("\\b");
+                    break;
+                case '\f':
+                    result.Append("\\f");
+                    break;
+                case '\n':
+                    result.Append("\\n");
+                    break;
+                case '\r':
+                    result.Append("\\r");
+                    break;
+                case '\t':
+                    result.Append("\\t");
+                    break;
+                default:
+                    var loneSurrogate = char.IsHighSurrogate(c)
+                        ? i + 1 >= value.Length || !char.IsLowSurrogate(value[i + 1])
+                        : char.IsLowSurrogate(c) && (i == 0 || !char.IsHighSurrogate(value[i - 1]));
+                    if (c < 0x20 || loneSurrogate)
+                    {
+                        result.Append("\\u").Append(((int)c).ToString("x4", CultureInfo.InvariantCulture));
+                    }
+                    else
+                    {
+                        result.Append(c);
+                    }
+                    break;
+            }
+        }
+        result.Append('"');
+    }
+}

package/eslint.config.mjs

@@ -0,0 +1,123 @@
+import eslint from '@eslint/js';
+import prettierRecommended from 'eslint-plugin-prettier/recommended';
+import { defineConfig } from 'eslint/config';
+import { readFileSync } from 'fs';
+import globals from 'globals';
+import tseslint from 'typescript-eslint';
+
+// These files use the CDK variant, which only exists after `make cdk`. Before, they are linted without
+// type information. After, all files are linted with tsconfig.lint-cdk.json, which resolves
+// `cdk-iam-floyd` to lib/.
+const cdkFiles = [
+  'lib/**/*.CDK.ts',
+  'lib/**/*-CDK.ts',
+  'examples/**/*.cdk.ts',
+  'test/cdk.ts',
+  'test/jsii/consumer/**/*.ts',
+];
+const isCdk =
+  JSON.parse(readFileSync('package.json', 'utf8')).name === 'cdk-iam-floyd';
+
+export default defineConfig(
+  {
+    ignores: [
+      '**/node_modules/',
+      '**/cdk.out/',
+      '**/*.d.ts',
+      'lib/**/*.js',
+      'bin/**/*.js',
+      'examples/**/*.js',
+      'helper/**/*.js',
+      'test/**/*.js',
+      'tooter/**/*.js',
+      'lib/generated/',
+      'dist/',
+      'java/target/',
+      'docs/build/',
+    ],
+  },
+  {
+    files: ['**/*.ts'],
+    extends: [
+      eslint.configs.recommended,
+      tseslint.configs.recommendedTypeChecked,
+      tseslint.configs.stylisticTypeChecked,
+    ],
+    languageOptions: {
+      parserOptions: isCdk
+        ? { project: 'tsconfig.lint-cdk.json' }
+        : { projectService: true },
+    },
+    rules: {
+      '@typescript-eslint/no-unused-vars': [
+        'error',
+        {
+          argsIgnorePattern: '^_',
+          varsIgnorePattern: '^_',
+          caughtErrorsIgnorePattern: '^_',
+        },
+      ],
+      '@typescript-eslint/no-deprecated': 'error',
+      '@typescript-eslint/naming-convention': [
+        'error',
+        {
+          selector: 'default',
+          format: ['camelCase'],
+          leadingUnderscore: 'allow',
+        },
+        { selector: 'import', format: ['camelCase', 'PascalCase'] },
+        {
+          selector: 'variable',
+          modifiers: ['const'],
+          format: ['camelCase', 'PascalCase', 'UPPER_CASE'],
+          leadingUnderscore: 'allow',
+        },
+        { selector: 'typeLike', format: ['PascalCase'] },
+        { selector: 'enumMember', format: ['camelCase', 'PascalCase'] },
+        // Keys of objects are given by the format, like IAM policies or AWS APIs
+        { selector: 'objectLiteralProperty', format: null },
+        { selector: 'typeProperty', format: null },
+      ],
+      'prefer-template': 'error',
+      // `@ts-expect-error` fails where the line is valid in the other variant
+      '@typescript-eslint/ban-ts-comment': [
+        'error',
+        { 'ts-ignore': 'allow-with-description' },
+      ],
+    },
+  },
+  {
+    // The layers call methods of the base class of the variant, which the standalone variant
+    // doesn't have
+    files: ['lib/shared/policy-statement/*.ts'],
+    rules: {
+      '@typescript-eslint/no-explicit-any': 'off',
+      '@typescript-eslint/no-this-alias': 'off',
+      '@typescript-eslint/no-unsafe-assignment': 'off',
+      '@typescript-eslint/no-unsafe-call': 'off',
+      '@typescript-eslint/no-unsafe-member-access': 'off',
+      '@typescript-eslint/no-unsafe-return': 'off',
+    },
+  },
+  {
+    files: cdkFiles,
+    extends: isCdk ? [] : [tseslint.configs.disableTypeChecked],
+  },
+  {
+    files: ['**/*.js', '**/*.mjs'],
+    extends: [eslint.configs.recommended],
+    languageOptions: { globals: globals.node },
+  },
+  {
+    files: ['docs/source/_static/js/**/*.js'],
+    languageOptions: {
+      globals: { ...globals.browser, $: 'readonly' },
+      sourceType: 'script',
+    },
+  },
+  prettierRecommended,
+  {
+    // `make cdk` writes code that isn't formatted. The formatting is checked in the standalone variant.
+    rules: isCdk ? { 'prettier/prettier': 'off' } : {},
+  },
+);

package/go/iamfloyd/go.mod

@@ -0,0 +1,3 @@
+module udondan.github.io/iam-floyd/go/iamfloyd
+
+go 1.21

package/go/iamfloyd/helpers.go

@@ -0,0 +1,25 @@
+package iamfloyd
+
+// String returns a pointer to a string, for the parameters of the API
+func String(value string) *string {
+	return &value
+}
+
+// Strings returns a pointer to a list of pointers to strings, for the parameters of the API
+func Strings(values ...string) *[]*string {
+	list := make([]*string, len(values))
+	for i := range values {
+		list[i] = &values[i]
+	}
+	return &list
+}
+
+// Number returns a pointer to a number, for the parameters of the API
+func Number(value float64) *float64 {
+	return &value
+}
+
+// Bool returns a pointer to a boolean, for the parameters of the API
+func Bool(value bool) *bool {
+	return &value
+}