[‼️]: ✏️README.mdt

@w5/redis_lua

test/main.coffee :

``coffee
#!/usr/bin/env coffee

> @w5/uridir
@w5/read
path > join
@w5/redis_lua
@w5/redis_lua/dot_bind.js

ROOT = uridir(import.meta)
LUA = read join ROOT,'redis.lua'

redis = {
fbinR:=>
new Uint8Array([])
fnload:(lua)=>
console.log lua
return
fstr:(args...)=>
console.log 'fstr', ...args
return
}


await RedisLua(redis).RedisLuaTest LUA

console.log '---'

BIND = DotBind redis

BIND.fstr.ipLimit()

await redis.ipLimit('key1','key2')('arg1','arg2')
`

output :

`
#!lua name=RedisLuaTest

local log = function(...)
local li = {}
for _, v in ipairs({ ... }) do
table.insert(li, cjson.encode(v))
end
redis.log(redis.LOG_NOTICE, unpack(li))
end

local _byZid = function(key, score)
score = tonumber(score)
local r = redis.call("ZRANGEBYSCORE", key, score, score, "LIMIT", 0, 1)
if r then
return r[1]
end
end

local intBin = function(n)
local t = {}
while n > 0 do
local r = math.fmod(n, 256)
table.insert(t, string.char(r))
n = (n - r) / 256
end
return table.concat(t)
end

local binInt = function(str)
local n = 0
local base = 1
for i = 1, #str do
local c = str:sub(i, i)
n = n + base * c:byte()
base = base * 256
end
return n
end

local HSET = function(key, field, val)
return redis.call("HSET", key, field, val)
end

local HGET = function(key, field)
return redis.call("HGET", key, field)
end

local HINCRBY = function(key, field, increment)
return redis.call("HINCRBY", key, field, increment)
end

local INCR = function(key)
return redis.call("INCR", key)
end

local ZSCORE = function(key, member)
local r = redis.call("ZSCORE", key, member)
if r then
return r.double
end
end

local ZADD_XX = function(key, member, score)
return redis.call("ZADD", key, "XX", score, member)
end

local ZADD = function(key, member, score)
return redis.call("ZADD", key, score, member)
end

local ZINCRBY = function(key, member, increment)
return redis.call("ZINCRBY", key, increment, member).double
end

local SISMEMBER = function(key, member)
return redis.call("SISMEMBER", key, member)
end

local EXPIRE = function(key, seconds)
return redis.call("EXPIRE", key, seconds)
end

local TTL = function(key)
return redis.call("TTL", key)
end

local _zid = function(kv, k)
local id = ZSCORE(kv, k)
if nil == id then
id = -ZINCRBY(kv, "", -1)
ZADD(kv, k, id)
end
return id
end

redis.register_function('zid',function(keys, args)
redis.setresp(3)
return _zid(keys[1], args[1])
end)

redis.register_function{
function_name='zmax',
callback=function(keys, args)
redis.setresp(3)
local zset = keys[1]
local max = redis.call("ZRANGE", zset, 0, 0, "REV", "WITHSCORES")
if next(max) ~= nil then
local min = args[1]
if min ~= nil then
min = tonumber(min)
local max = max[1]
if max[2].double > min then
return max[1]
end
end
end
end,
flags={'no-writes'}
}

redis.register_function('zero',function(keys, args)
redis.setresp(3)
local key = keys[1]
local t = redis.call("ZRANGEBYSCORE", key, "(0", "+inf")
local r = {}
for i = 1, #t do
table.insert(r, 0)
table.insert(r, t[i])
end
redis.call("ZADD", key, unpack(r))
end)

local _ztouch = function(func, keys, args)
local zset = keys[1]
local key = args[1]
local max = redis.call("ZRANGE", zset, 0, 0, "REV", "WITHSCORES")
if next(max) == nil then
max = 1
else
max = max[1]
local val = max[2].double
if max[1] == key and val ~= 0 then
return
end
max = val + 1
end
func(zset, key, max)
end

redis.register_function('ztouch',function(keys, args)
redis.setresp(3)
_ztouch(ZADD, keys, args)
end)

redis.register_function('ztouchXx',function(keys, args)
redis.setresp(3)
_ztouch(ZADD_XX, keys, args)
end)

redis.register_function{
function_name='RedisLuaTestVer',
callback=function()
redis.setresp(3)
return "\188\0\180\11\100\122\172\50\199\66\224\34\38\70\84\131\139\84\230\175\183\85\160\149\120\156\137\85\99\119\50\166"
end,
flags={'no-writes'}
}
---
fstr ipLimit [ 'key1', 'key2' ] [ 'arg1', 'arg2' ]
``